[JavaScript] some improvements and enhancements to JavaScript client

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/JavascriptClientCodegen.java

@@ -164,11 +164,11 @@ public void preprocessSwagger(Swagger swagger) {
 
         if (swagger.getInfo() != null) {
             Info info = swagger.getInfo();
-            if (projectName == null &&  info.getTitle() != null) {
+            if (StringUtils.isBlank(projectName) && info.getTitle() != null) {
                 // when projectName is not specified, generate it from info.title
                 projectName = dashize(info.getTitle());
             }
-            if (projectVersion == null) {
+            if (StringUtils.isBlank(projectVersion)) {
                 // when projectVersion is not specified, use info.version
                 projectVersion = info.getVersion();
             }
@@ -185,13 +185,13 @@ public void preprocessSwagger(Swagger swagger) {
         }
 
         // default values
-        if (projectName == null) {
+        if (StringUtils.isBlank(projectName)) {
             projectName = "swagger-js-client";
         }
-        if (moduleName == null) {
+        if (StringUtils.isBlank(moduleName)) {
             moduleName = camelize(underscore(projectName));
         }
-        if (projectVersion == null) {
+        if (StringUtils.isBlank(projectVersion)) {
             projectVersion = "1.0.0";
         }
         if (projectDescription == null) {
@@ -290,14 +290,13 @@ public String toApiImport(String name) {
     @Override
     public String getTypeDeclaration(Property p) {
         if (p instanceof ArrayProperty) {
-        //    ArrayProperty ap = (ArrayProperty) p;
-       //     Property inner = ap.getItems();
-            return getSwaggerType(p); // TODO: + "/* <" + getTypeDeclaration(inner) + "> */";
+            ArrayProperty ap = (ArrayProperty) p;
+            Property inner = ap.getItems();
+            return "[" + getTypeDeclaration(inner) + "]";
         } else if (p instanceof MapProperty) {
             MapProperty mp = (MapProperty) p;
             Property inner = mp.getAdditionalProperties();
-
-            return getSwaggerType(p) + "<String, " + getTypeDeclaration(inner) + ">";
+            return "{String: " + getTypeDeclaration(inner) + "}";
         }
         return super.getTypeDeclaration(p);
     }
@@ -318,10 +317,18 @@ public String toDefaultValue(Property p) {
     @Override
     public String toDefaultValueWithParam(String name, Property p) {
         if (p instanceof RefProperty) {
-            return ".constructFromObject(data." + name + ");";
+            return ".constructFromObject(data['" + name + "']);";
+        } else {
+          String type = normalizeType(getTypeDeclaration(p));
+          return " = ApiClient.convertToType(data['" + name + "'], " + type + ");";
         }
+    }
 
-        return super.toDefaultValueWithParam(name, p);
+    /**
+     * Normalize type by wrapping primitive types with single quotes.
+     */
+    public String normalizeType(String type) {
+      return type.replaceAll("\\b(Boolean|Integer|Number|String|Date)\\b", "'$1'");
     }
 
     @Override
@@ -357,6 +364,15 @@ public String toOperationId(String operationId) {
         return camelize(sanitizeName(operationId), true);
     }
 
+    @Override
+    public CodegenOperation fromOperation(String path, String httpMethod, Operation operation, Map<String, Model> definitions, Swagger swagger) {
+      CodegenOperation op = super.fromOperation(path, httpMethod, operation, definitions, swagger);
+      if (op.returnType != null) {
+        op.returnType = normalizeType(op.returnType);
+      }
+      return op;
+    }
+
     @Override
     public CodegenModel fromModel(String name, Model model, Map<String, Model> allDefinitions) {
         CodegenModel codegenModel = super.fromModel(name, model, allDefinitions);
@@ -417,11 +433,6 @@ public Map<String, Object> postProcessModels(Map<String, Object> objs) {
         return objs;
     }
 
-    @Override
-    public Map<String, Object> postProcessOperations(Map<String, Object> objs) {
-        return objs;
-    }
-
     @Override
     protected boolean needToImport(String type) {
         return !defaultIncludes.contains(type)

modules/swagger-codegen/src/main/resources/Javascript/ApiClient.mustache

@@ -88,9 +88,15 @@
    * Check if the given parameter value is like file content.
    */
   ApiClient.prototype.isFileParam = function isFileParam(param) {
-    // Buffer or fs.ReadStream in Node.js
-    if (typeof module === 'object' && module.exports &&
-        (param instanceof Buffer || param instanceof require('fs').ReadStream)) {
+    // fs.ReadStream in Node.js (but not in runtime like browserify)
+    if (typeof window === 'undefined' &&
+        typeof require === 'function' &&
+        require('fs') &&
+        param instanceof require('fs').ReadStream) {
+      return true;
+    }
+    // Buffer in Node.js
+    if (typeof Buffer === 'function' && param instanceof Buffer) {
       return true;
     }
     // Blob in browser
@@ -125,9 +131,23 @@
     return newParams;
   };
 
+  ApiClient.prototype.deserialize = function deserialize(response, returnType) {
+    if (response == null || returnType == null) {
+      return null;
+    }
+    // Rely on Superagent for parsing response body.
+    // See http://visionmedia.github.io/superagent/#parsing-response-bodies
+    var data = response.body;
+    if (data == null) {
+      return null;
+    }
+    return ApiClient.convertToType(data, returnType);
+  };
+
   ApiClient.prototype.callApi = function callApi(path, httpMethod, pathParams,
       queryParams, headerParams, formParams, bodyParam, contentTypes, accepts,
-      callback) {
+      returnType, callback) {
+    var _this = this;
     var url = this.buildUrl(path, pathParams);
     var request = superagent(httpMethod, url);
 
@@ -169,14 +189,72 @@
 
     request.end(function(error, response) {
       if (callback) {
-        var data = response && response.body;
+        var data = null;
+        if (!error) {
+          data = _this.deserialize(response, returnType);
+        }
         callback(error, data, response);
       }
     });
 
     return request;
   };
 
+  ApiClient.parseDate = function parseDate(str) {
+    str = str.replace(/T/i, ' ');
+    return new Date(str);
+  };
+
+  ApiClient.convertToType = function convertToType(data, type) {
+    switch (type) {
+      case 'Boolean':
+        return Boolean(data);
+      case 'Integer':
+        return parseInt(data, 10);
+      case 'Number':
+        return parseFloat(data);
+      case 'String':
+        return String(data);
+      case 'Date':
+        return this.parseDate(String(data));
+      default:
+        if (typeof type === 'function') {
+          // for model type like: User
+          var model = new type();
+          model.constructFromObject(data);
+          return model;
+        } else if (Array.isArray(type)) {
+          // for array type like: ['String']
+          var itemType = type[0];
+          return data.map(function(item) {
+            return ApiClient.convertToType(item, itemType);
+          });
+        } else if (typeof type === 'object') {
+          // for plain object type like: {'String': 'Integer'}
+          var keyType, valueType;
+          for (var k in type) {
+            if (type.hasOwnProperty(k)) {
+              keyType = k;
+              valueType = type[k];
+              break;
+            }
+          }
+          var result = {};
+          for (var k in data) {
+            if (data.hasOwnProperty(k)) {
+              var key = ApiClient.convertToType(k, keyType);
+              var value = ApiClient.convertToType(data[k], valueType);
+              result[key] = value;
+            }
+          }
+          return result;
+        } else {
+          // for unknown type, return the data directly
+          return data;
+        }
+    }
+  };
+
   ApiClient.default = new ApiClient();
 
   return ApiClient;

modules/swagger-codegen/src/main/resources/Javascript/api.mustache

@@ -53,28 +53,12 @@
 
       var contentTypes = [<#consumes>'<mediaType>'<#hasMore>, </hasMore></consumes>];
       var accepts = [<#produces>'<mediaType>'<#hasMore>, </hasMore></produces>];
-
-      var handleResponse = null;
-      if (callback) {
-        handleResponse = function(error, data, response) {<#returnType><#returnTypeIsPrimitive>
-          callback(error, data, response);</returnTypeIsPrimitive><^returnTypeIsPrimitive><#isListContainer>
-          // TODO: support deserializing array of models
-          callback(error, data, response);</isListContainer><^isListContainer>
-          if (!error && data) {
-            var result = new <&returnType>();
-            result.constructFromObject(data);
-            callback(error, result, response);
-          } else {
-            callback(error, data, response);
-          }</isListContainer></returnTypeIsPrimitive></returnType><^returnType>
-          callback(error, data, response);</returnType>
-        };
-      }
+      var returnType = <#returnType><&returnType></returnType><^returnType>null</returnType>;
 
       return this.apiClient.callApi(
         '<&path>', '<httpMethod>',
         pathParams, queryParams, headerParams, formParams, postBody,
-        contentTypes, accepts, handleResponse
+        contentTypes, accepts, returnType, callback
       );
       <={{ }}=>
     }

modules/swagger-codegen/src/main/resources/Javascript/enumClass.mustache

@@ -1,18 +1,18 @@
 
 //export module
-if ( typeof define === "function" && define.amd ) {     
-	define('{{datatypeWithEnum}}', ['jquery'], function($) {
+if ( typeof define === "function" && define.amd ) {
+	define('{{datatypeWithEnum}}', [], function() {
         return {{datatypeWithEnum}};
 	 });
 }
 
 var {{datatypeWithEnum}} = function {{datatypeWithEnum}}() {
 	var self = this;
-	
+
 {{#allowableValues}}{{#enumVars}}
 	/**
-	 * @const 
-	 */ 
+	 * @const
+	 */
 	self.{{name}} = "{{value}}"{{^-last}},
 	{{/-last}}{{#-last}};{{/-last}}{{/enumVars}}{{/allowableValues}}
 

modules/swagger-codegen/src/main/resources/Javascript/model.mustache

@@ -1,18 +1,18 @@
 (function(root, factory) {
   if (typeof define === 'function' && define.amd) {
     // AMD. Register as an anonymous module.
-    define([undefined{{#imports}}, './{{import}}'{{/imports}}], factory);
+    define([undefined, '../ApiClient'{{#imports}}, './{{import}}'{{/imports}}], factory);
   } else if (typeof module === 'object' && module.exports) {
     // CommonJS-like environments that support module.exports, like Node.
-    module.exports = factory(undefined{{#imports}}, require('./{{import}}'){{/imports}});
+    module.exports = factory(undefined, require('../ApiClient'){{#imports}}, require('./{{import}}'){{/imports}});
   } else {
     // Browser globals (root is window)
     if (!root.{{moduleName}}) {
       root.{{moduleName}} = {};
     }
-    factory(root.{{moduleName}}{{#imports}}, root.{{moduleName}}.{{import}}{{/imports}});
+    factory(root.{{moduleName}}, root.{{moduleName}}.ApiClient{{#imports}}, root.{{moduleName}}.{{import}}{{/imports}});
   }
-}(this, function(module{{#imports}}, {{import}}{{/imports}}) {
+}(this, function(module, ApiClient{{#imports}}, {{import}}{{/imports}}) {
   'use strict';
 
   {{#models}}{{#model}}
@@ -32,16 +32,17 @@
      * minimum: {{minimum}}{{/minimum}}{{#maximum}}
      * maximum: {{maximum}}{{/maximum}}
      **/
-    self.{{name}} = {{#required}}{{name}}{{/required}}{{^required}}{{{defaultValue}}}{{/required}};
+    self['{{baseName}}'] = {{#required}}{{name}}{{/required}}{{^required}}{{{defaultValue}}}{{/required}};
     {{/vars}}
 
     self.constructFromObject = function(data) {
       if (!data) {
-        return;
+        return this;
       }
       {{#vars}}
-      self.{{name}}{{{defaultValueWithParam}}}
+      self['{{baseName}}']{{{defaultValueWithParam}}}
       {{/vars}}
+      return this;
     }
 
     {{#vars}}
@@ -52,19 +53,19 @@
      * @return {{=<% %>=}}{<% datatypeWithEnum %>}<%={{ }}=%>
      **/
     self.{{getter}} = function() {
-      return self.{{name}};
+      return self['{{baseName}}'];
     }
 
     /**{{#description}}
      * set {{{description}}}{{/description}}
      * @param {{=<% %>=}}{<% datatypeWithEnum %>}<%={{ }}=%> {{name}}
      **/
-    self.{{setter}} = function ({{name}}) {
-      self.{{name}} = {{name}};
+    self.{{setter}} = function({{name}}) {
+      self['{{baseName}}'] = {{name}};
     }
     {{/vars}}
 
-    self.toJson = function () {
+    self.toJson = function() {
       return JSON.stringify(self);
     }
   };