Add splitter

.gitignore

@@ -6,3 +6,4 @@ wks.*
 *.swp
 
 tmp-*
+zz/

.jshintignore

@@ -0,0 +1 @@
+lib/splitter.js

.jshintrc

@@ -7,7 +7,7 @@
   "curly": true,
   "eqeqeq": true,
   "immed": true,
-  "indent": 4,
+  "indent": 2,
   "latedef": true,
   "newcap": false,
   "noarg": true,
@@ -18,6 +18,5 @@
   "strict": true,
   "trailing": true,
   "smarttabs": true,
-  "globals": {
-  }
+  "globals": {}
 }

README.md

@@ -80,6 +80,34 @@ In addition to the common options listed below, `getCustomCode()` *requires* a `
     description: swagger object
 ```
 
+If it is required to generate multiple files for Node (i. e. multiple methods based on the initial JSON) provide the following option:
+
+    multiple: true
+
+When this option is provided, the module will return an array of objects, that have the following structure:
+
+    { content: <STRING>,
+      file: <STRING>,
+      functions: <ARRAY>,
+      directory: <STRING>,
+      isWrapper: <BOOLEAN> }
+
+This structure describes a file, that contains generated REST APIs 
+
+`content` - file contents, single string
+
+`file` - file name
+
+`functions` - array of function names
+
+`directory` - name of the directory, that should be created for this file
+
+`isWrapper` - will be **true** for wrapper file
+
+Resulting array should always contain a single wrapper file
+
+**Please notice**: when using this option, the module returns a **promise**
+
 ### Template Variables
 The following data are passed to the [mustache templates](https://github.com/janl/mustache.js):
 

lib/codegen.js

@@ -5,7 +5,9 @@ var Mustache = require('mustache');
 var beautify = require('js-beautify').js_beautify;
 var lint = require('jshint').JSHINT;
 var _ = require('lodash');
+
 var ts = require('./typescript');
+var splitter = require('./splitter');
 
 var normalizeName = function(id) {
     return id.replace(/\.|\-|\{|\}|\s/g, '_');
@@ -47,41 +49,44 @@ var getViewForSwagger2 = function(opts, type){
         definitions: []
     };
 
-    _.forEach(swagger.paths, function(api, path){
+    _.forEach(swagger.paths, function(api, path) {
         var globalParams = [];
         /**
          * @param {Object} op - meta data for the request
          * @param {string} m - HTTP method name - eg: 'get', 'post', 'put', 'delete'
          */
-        _.forEach(api, function(op, m){
-            if(m.toLowerCase() === 'parameters') {
+        _.forEach(api, function(op, m) {
+            if (m.toLowerCase() === 'parameters') {
                 globalParams = op;
             }
         });
-        _.forEach(api, function(op, m){
+        _.forEach(api, function(op, m) {
             var M = m.toUpperCase();
-            if(M === '' || authorizedMethods.indexOf(M) === -1) {
+            // check if this is a supported method
+            if (M === '' || authorizedMethods.indexOf(M) === -1) {
                 return;
             }
             var secureTypes = [];
-            if(swagger.securityDefinitions !== undefined || op.security !== undefined) {
-							  var mergedSecurity = _.merge([], swagger.security, op.security).map(function(security){
+            if (swagger.securityDefinitions !== undefined || op.security !== undefined) {
+							  var mergedSecurity = _.merge([], swagger.security, op.security).map(function(security) {
 							      return Object.keys(security);
                 });
-							  if(swagger.securityDefinitions) {
-									for(var sk in swagger.securityDefinitions) {
-                    if(mergedSecurity.join(',').indexOf(sk) !== -1){
+							  if (swagger.securityDefinitions) {
+									for (var sk in swagger.securityDefinitions) {
+                    if (mergedSecurity.join(',').indexOf(sk) !== -1) {
 											secureTypes.push(swagger.securityDefinitions[sk].type);
                     }
 									}
                 }
             }
+
             var methodName = (op.operationId ? normalizeName(op.operationId) : getPathToMethodName(opts, m, path));
+
             // Make sure the method name is unique
-            if(methods.indexOf(methodName) !== -1) {
+            if (methods.indexOf(methodName) !== -1) {
               var i = 1;
-              while(true) {
-                if(methods.indexOf(methodName + '_' + i) !== -1) {
+              while (true) {
+                if (methods.indexOf(methodName + '_' + i) !== -1) {
                   i++;
                 } else {
                   methodName = methodName + '_' + i;
@@ -105,8 +110,14 @@ var getViewForSwagger2 = function(opts, type){
 							  isSecureApiKey: secureTypes.indexOf('apiKey') !== -1,
 							  isSecureBasic: secureTypes.indexOf('basic') !== -1,
                 parameters: [],
-                headers: []
+                headers: [],
             };
+
+            // add 'destination' field if 'multiple: true'
+            if (opts.multiple) {
+              method.destination = op.tags[0].toLowerCase();
+            }
+
 					  if(method.isSecure && method.isSecureToken) {
 					      data.isSecureToken = method.isSecureToken;
 					  }
@@ -117,7 +128,7 @@ var getViewForSwagger2 = function(opts, type){
 						    data.isSecureBasic = method.isSecureBasic;
 					  }
 					  var produces = op.produces || swagger.produces;
-            if(produces) {
+            if (produces) {
                 method.headers.push({
                   name: 'Accept',
                   value: `'${produces.map(function(value) { return value; }).join(', ')}'`,
@@ -253,9 +264,16 @@ var getViewForSwagger1 = function(opts, type){
     return data;
 };
 
+/**
+ * Generate code based on the input file
+ * @param opts <OBJECT> - options for the file generation
+ * @param type <STRING> - type of code / file to be generated (angular, custom, node, react, typescript)
+ * @returns {*}
+ */
 var getCode = function(opts, type) {
     // For Swagger Specification version 2.0 value of field 'swagger' must be a string '2.0'
     var data = opts.swagger.swagger === '2.0' ? getViewForSwagger2(opts, type) : getViewForSwagger1(opts, type);
+
     if (type === 'custom') {
         if (!_.isObject(opts.template) || !_.isString(opts.template.class)  || !_.isString(opts.template.method)) {
             throw new Error('Unprovided custom template. Please use the following template: template: { class: "...", method: "...", request: "..." }');
@@ -265,9 +283,16 @@ var getCode = function(opts, type) {
             opts.template = {};
         }
         var templates = __dirname + '/../templates/';
-        opts.template.class = opts.template.class || fs.readFileSync(templates + type + '-class.mustache', 'utf-8');
-        opts.template.method = opts.template.method || fs.readFileSync(templates + (type === 'typescript' ? 'typescript-' : '') + 'method.mustache', 'utf-8');
-        if(type === 'typescript') {
+
+        // choose templates based on the 'multiple' option TODO: Typescript support?
+        if (opts.multiple) {
+          opts.template.class = fs.readFileSync(templates + 'multi-class.mustache', 'utf-8');
+          opts.template.method = fs.readFileSync(templates + 'multi-method.mustache', 'utf-8');
+        } else {
+          opts.template.class = opts.template.class || fs.readFileSync(templates + type + '-class.mustache', 'utf-8');
+          opts.template.method = opts.template.method || fs.readFileSync(templates + (type === 'typescript' ? 'typescript-' : '') + 'method.mustache', 'utf-8');
+        }
+        if (type === 'typescript') {
             opts.template.type = opts.template.type || fs.readFileSync(templates + 'type.mustache', 'utf-8');
         }
     }
@@ -302,6 +327,9 @@ var getCode = function(opts, type) {
             }
         });
     }
+    if (opts.multiple) {
+        return splitter.split(source, opts.className);
+    }
     if (opts.beautify === undefined || opts.beautify === true) {
         return beautify(source, { indent_size: 4, max_preserve_newlines: 2 });
     } else {

lib/splitter.js

@@ -0,0 +1,145 @@
+const beautify = require('js-beautify').js;
+const fs = require('fs');
+const { transform } = require('lebab');
+
+/**
+ * First letter capitalization, utility function
+ * @param string
+ * @returns {string}
+ */
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+
+/**
+ * Split the code to create multiple files and directories
+ * @param {string} source - source code generated by swagger-js-codegen (using special templates!)
+ * @param {string} className - specified class name
+ * @returns {array} - array of objects (files and wrapper)
+ */
+async function split(source, className) {
+  try {
+    // convert ES5 to ES6
+    const { code, warnings } = transform(source, ['let', 'arrow', 'arrow-return', 'class']);
+
+    // show conversion errors and warnings
+    if (warnings && warnings.length && warnings.length > 0) {
+      console.log('> codegen-splitter @ ES6 conversion warnings:\n', warnings);
+    }
+
+    // create the source file TODO: better understanding of the file placement
+    fs.writeFileSync(`${__dirname}/source.js`, code, (err) => {
+      if (err) {
+        throw new Error(err);
+      }
+    });
+
+    // load source file and get all of the available methods from the class
+    console.log('> various', `${__dirname}/source.js`, `${capitalize(className.toLowerCase())}`);
+    const Instance = require(`${__dirname}/source.js`)[`${capitalize(className.toLowerCase())}`];
+    console.log('> ins', Instance);
+    const methods = Object.getOwnPropertyNames(Instance.prototype).filter(m => m !== 'constructor');
+
+    // abort everything if there are no methods (i. e. incorrect JSON or something went wrong)
+    if (methods.length === 0) {
+      return console.log('> Methods not found');
+    }
+
+    // create new instance of the class, use it as a provider of the code
+    const provider = new Instance();
+
+    // process all of the methods, store code in array
+    const destinations = [];
+    methods.forEach((method) => {
+      let standalone = provider[method].toString();
+      let functionName = standalone.split('(req, res)')[0];
+      const destination = functionName.split('_')[0];
+      functionName = functionName.split('_')[1];
+      standalone = `async function ${functionName}(req, res) ${standalone.split('(req, res)')[1]}`;
+      destinations.push({
+        content: standalone,
+        file: destination,
+        function: functionName,
+      });
+    });
+
+    // create file list
+    const files = [];
+    destinations.forEach((f) => {
+      if (!files.some(entry => entry.file === f.file)) {
+        files.push({
+          content: '',
+          file: f.file,
+          functions: [],
+        });
+      }
+    });
+
+    // building the controllers
+    files.forEach((file, i) => {
+      destinations.forEach((d) => {
+        if (file.file === d.file) {
+          files[i].content = `${files[i].content}
+
+            ${d.content}`;
+          files[i].functions.push(d.function);
+        }
+      });
+    });
+
+    // add 'use strict' and exporting
+    files.forEach((file, i) => {
+      let fList = '';
+      file.functions.forEach((f) => {
+        fList = `${fList}
+          ${f},`;
+      });
+      files[i].content = beautify(`'use strict';
+
+      /* auto-generated: ${file.file}.controller.js */
+      ${file.content}
+
+      module.exports = {
+        ${fList}
+      };`, { indent_size: 2 });
+    });
+
+    // delete the source file TODO: better understanding of the file placement
+    await fs.unlink(`${__dirname}/source.js`, (err) => {
+      if (err) {
+        throw new Error(err);
+      }
+    });
+
+    // create API wrapper TODO: what should be inside of the wrapper? What to export?
+    let wrapperContent = '';
+    files.forEach((file) => {
+      const name = file.file;
+      wrapperContent = `${wrapperContent}
+        const ${name} = require('./${name}/${name}.controller.js');`;
+    });
+    const wrapper = {
+      content: beautify(wrapperContent, { indent_size: 2 }),
+      directory: null,
+      file: 'index.js', // TODO: wrapper name?
+      isWrapper: true,
+    };
+
+    // finalize and return
+    files.forEach((file, i) => {
+      files[i].directory = file.file;
+      files[i].file = `${file.file}.controller.js`;
+      files[i].isWrapper = false;
+    });
+    files.push(wrapper);
+
+    return files;
+  } catch (err) {
+    console.log('> err', err);
+    throw new Error(err);
+  }
+}
+
+module.exports = {
+  split,
+};