Feature/support for multifiles

index.js

@@ -10,15 +10,19 @@ module.exports = {
     if (schema.validated) {
       return schema.convert(cb);
     }
-
     return cb(null, schema.validationResult);
   },
 
-  validate: function(input) {
+  validate: function (input) {
     var schema = new SchemaPack(input);
     return schema.validationResult;
   },
 
+  mergeAndValidate: function (input, cb) {
+    var schema = new SchemaPack(input);
+    schema.mergeAndValidate(cb);
+  },
+
   getOptions: function() {
     return SchemaPack.getOptions();
   },

lib/parse.js

@@ -1,8 +1,11 @@
-var yaml = require('js-yaml');
+var yaml = require('js-yaml'),
+  fs = require('fs'),
+  resolver = require('oas-resolver'),
+  yamlParse = require('yaml');
 
 module.exports = {
 
-  asJson: function(spec) {
+  asJson: function (spec) {
     try {
       return JSON.parse(spec);
     }
@@ -11,7 +14,7 @@ module.exports = {
     }
   },
 
-  asYaml: function(spec) {
+  asYaml: function (spec) {
     try {
       return yaml.safeLoad(spec);
     }
@@ -20,8 +23,15 @@ module.exports = {
     }
   },
 
-  validateRoot: function(spec) {
-    // Checking for the all the required properties in the specificatio
+  /**
+   * Validate Spec to check if some of the required fields are present.
+   *
+   * @param {Object} spec OpenAPI spec
+   * @return {Object} Validation result
+   */
+  validateSpec: function (spec) {
+
+    // Checking for the all the required properties in the specification
     if (!spec.hasOwnProperty('openapi')) {
       return {
         result: false,
@@ -42,25 +52,165 @@ module.exports = {
         reason: 'Specification must contain an Info Object for the meta-data of the API'
       };
     }
-    if (!spec.info.hasOwnProperty('title')) {
-      return {
-        result: false,
-        reason: 'Specification must contain a title in order to generate a collection'
-      };
-    }
+    if (!spec.info.hasOwnProperty('$ref')) {
+      if (!spec.info.hasOwnProperty('title')) {
+        return {
+          result: false,
+          reason: 'Specification must contain a title in order to generate a collection'
+        };
+      }
 
-    if (!spec.info.hasOwnProperty('version')) {
-      return {
-        result: false,
-        reason: 'Specification must contain a semantic version number of the API in the Info Object'
-      };
+      if (!spec.info.hasOwnProperty('version')) {
+        return {
+          result: false,
+          reason: 'Specification must contain a semantic version number of the API in the Info Object'
+        };
+      }
     }
 
-
     // Valid specification
     return {
       result: true,
       openapi: spec
     };
+  },
+
+  /** Converts OpenAPI input to OpenAPI Object
+   * @param {String} openApiSpec OpenAPI input in string
+   * @returns {Object} oasObject
+   */
+  getOasObject: function (openApiSpec) {
+    let oasObject = openApiSpec,
+      detailedError;
+    try {
+      oasObject = this.asYaml(openApiSpec);
+    }
+    catch (yamlException) {
+      // Not valid YAML, could be a JSON as well
+      try {
+        oasObject = this.asJson(openApiSpec);
+      }
+      catch (jsonException) {
+        // It's neither JSON nor YAML
+        // try and determine json-ness or yaml-ness
+        if (openApiSpec && openApiSpec[0] === '{') {
+          // probably JSON
+          detailedError = ' ' + jsonException.message;
+        }
+        else if (openApiSpec && openApiSpec.indexOf('openapi:') === 0) {
+          // probably YAML
+          detailedError = ' ' + yamlException.message;
+        }
+        return {
+          result: false,
+          reason: 'Invalid format. Input must be in YAML or JSON format.' + detailedError
+        };
+      }
+    }
+
+    return {
+      result: true,
+      oasObject
+    };
+  },
+
+  /** Given an array of files returns the root OAS file if present
+   *
+   * @param {Array} filesPathArray Array of file paths
+   * @return {String} rootFile
+   */
+  getRootFiles: function (filesPathArray) {
+    let rootFilesArray = [];
+
+    filesPathArray.forEach((filePath) => {
+      try {
+        let file = fs.readFileSync(filePath.fileName, 'utf8'),
+          oasObject,
+          obj = this.getOasObject(file);
+
+        if (obj.result) {
+          oasObject = obj.oasObject;
+        }
+        else {
+          throw new Error(obj.reason);
+        }
+        if (this.validateSpec(oasObject).result) {
+          rootFilesArray.push(filePath.fileName);
+        }
+      }
+      catch (e) {
+        throw new Error(e.message);
+      }
+    });
+    return rootFilesArray;
+  },
+
+  /**
+   * Resolve file references and generate single OAS Object
+   *
+   * @param {Object} openapi OpenAPI
+   * @param {Object} options options
+   * @return {Object} Resolved content
+   */
+  resolveContent: function (openapi, options) {
+    return resolver.resolve(openapi, options.source, {
+      options: Object.assign({}, options),
+      resolve: true,
+      cache: [],
+      externals: [],
+      externalRefs: {},
+      rewriteRefs: true,
+      openapi: openapi
+    });
+  },
+
+  /** Resolves all OpenAPI file references and returns a single OAS Object
+   *
+   * @param {Object} source Root file path
+   * @param {Object} options Configurable options as per oas-resolver module.
+   * @return {Object} Resolved OpenAPI Schema
+   */
+  mergeFiles: function(source, options = {}) {
+    options.source = source;
+    options.origin = source;
+    return this.readFileAsync(source, 'utf8')
+      .then((content) => {
+        try {
+          return yamlParse.parse(content, { prettyErrors: true });
+        }
+        catch (err) {
+          throw new Error('\nLine: ' + err.linePos.start.line + ', col: ' +
+           err.linePos.start.col + ' ' + err.message);
+        }
+      }, (err) => {
+        throw new Error(err.message);
+      })
+      .then((unresolved) => {
+        if (options.resolve === true) {
+          return this.resolveContent(unresolved, options);
+        }
+      }, (err) => {
+        throw err;
+      })
+      .then((result) => {
+        return result.openapi;
+      }, (err) => {
+        throw err;
+      });
+  },
+
+  /** Read File asynchronously
+   *
+   * @param {String} filePath Path of the file.
+   * @param {String} encoding encoding
+   * @return {String} Contents of the file
+   */
+  readFileAsync: function(filePath, encoding) {
+    return new Promise((resolve, reject) => {
+      fs.readFile(filePath, encoding, (err, data) => {
+        if (err) { reject(err); }
+        else { resolve(data); }
+      });
+    });
   }
 };

lib/schemaUtils.js

@@ -287,42 +287,24 @@ module.exports = {
    */
   parseSpec: function (openApiSpec) {
     var openApiObj = openApiSpec,
-      detailedError,
+      obj,
       rootValidation;
 
     // If the open api specification is a string could be YAML or JSON
     if (typeof openApiSpec === 'string') {
-      try {
-        openApiObj = parse.asYaml(openApiSpec);
+      obj = parse.getOasObject(openApiSpec);
+      if (obj.result) {
+        openApiObj = obj.oasObject;
       }
-      catch (yamlException) {
-        // Not valid YAML, could be a JSON as well
-        try {
-          openApiObj = parse.asJson(openApiSpec);
-        }
-        catch (jsonException) {
-          // It's neither JSON nor YAML
-          // try and determine json-ness or yaml-ness
-          if (openApiSpec && openApiSpec[0] === '{') {
-            // probably JSON
-            detailedError = ' ' + jsonException.message;
-          }
-          else if (openApiSpec && openApiSpec.indexOf('openapi:') === 0) {
-            // probably YAML
-            detailedError = ' ' + yamlException.message;
-          }
-          return {
-            result: false,
-            reason: 'Invalid format. Input must be in YAML or JSON format.' + detailedError
-          };
-        }
+      else {
+        return obj;
       }
     }
 
     // spec is a valid JSON object at this point
 
     // Validate the root level object for semantics
-    rootValidation = parse.validateRoot(openApiObj);
+    rootValidation = parse.validateSpec(openApiObj);
     if (!rootValidation.result) {
       return {
         result: false,

lib/schemapack.js

@@ -6,11 +6,17 @@ const COLLECTION_NAME = 'Converted from OpenAPI',
   async = require('async'),
   sdk = require('postman-collection'),
   schemaUtils = require('./schemaUtils.js'),
+  OasResolverOptions = {
+    resolve: true, // Resolve external references
+    jsonSchema: true // Treat $ref like JSON Schema and convert to OpenAPI Schema Objects
+  },
+  parse = require('./parse.js'),
   getOptions = require('./options').getOptions,
   transactionSchema = require('../assets/validationRequestListSchema.json'),
   utils = require('./utils.js'),
   _ = require('lodash'),
   fs = require('fs'),
+  // options for oas-resolver
 
   // This provides the base class for
   // errors with the input OpenAPI spec
@@ -97,6 +103,14 @@ class SchemaPack {
         return this.validationResult;
       }
     }
+    else if (input.type === 'folder') {
+      this.validationResult = {
+        result: false,
+        reason: 'Input data not validated, please call mergeAndValidate() for input.type \'folder\''
+      };
+
+      return this.validationResult;
+    }
     else {
       // invalid input type
       this.validationResult = {
@@ -133,6 +147,55 @@ class SchemaPack {
     return this.validationResult;
   }
 
+  mergeAndValidate (cb) {
+    let input = this.input,
+      validationResult,
+      rootFiles;
+
+    try {
+      rootFiles = parse.getRootFiles(input.data);
+    }
+    catch (e) {
+      return cb(null, {
+        result: false,
+        reason: e
+      });
+    }
+    if (rootFiles.length > 1) {
+      this.validationResult = {
+        result: false,
+        reason: 'More than one root file not supported.'
+      };
+      return cb(null, this.validationResult);
+    }
+    if (rootFiles.length) {
+      parse.mergeFiles(rootFiles[0], OasResolverOptions)
+        .then((spec) => {
+          this.input = {
+            type: 'json',
+            data: spec
+          };
+          validationResult = this.validate();
+
+          return cb(null, validationResult);
+        })
+        .catch((err) => {
+          this.validationResult = {
+            result: false,
+            reason: 'Error while merging files.',
+            error: err
+          };
+          return cb(null, this.validationResult);
+        });
+    }
+    else {
+      return cb(null, {
+        result: false,
+        reason: 'No root files present / input is not an OpenAPI spec.'
+      });
+    }
+  }
+
   // convert method, this is called when you want to convert a schema that you've already loaded
   // in the constructor
   convert (callback) {