Update schemapack to return analytics from the module and refactor deref

Author: umeshp7

lib/deref.js

@@ -84,36 +84,36 @@ module.exports = {
   /**
    * Creates a schema that's a union of all input schemas (only type: object is supported)
    *
-   * @param {array} schemaArr - array of schemas, all of which must be valid in the returned object
-   * @param {string} parameterSourceOption tells that the schema object is of request or response
-   * @param {*} components components in openapi spec.
-   * @param {object} schemaResolutionCache stores already resolved references
-   * @param {*} resolveFor - resolve refs for validation/conversion (value to be one of VALIDATION/CONVERSION)
-   * @param {string} resolveTo The desired JSON-generation mechanism (schema: prefer using the JSONschema to
+   * @param {array} schemaArr REQUIRED - array of schemas, all of which must be valid in the returned object
+   * @param {string} parameterSourceOption REQUIRED tells that the schema object is of request or response
+   * @param {*} components REQUIRED components in openapi spec.
+   * @param {object} options - REQUIRED a list of options to indicate the type of resolution needed.
+   * @param {*} options.resolveFor - resolve refs for validation/conversion (value to be one of VALIDATION/CONVERSION)
+   * @param {string} options.resolveTo The desired JSON-generation mechanism (schema: prefer using the JSONschema to
      generate a fake object, example: use specified examples as-is). Default: schema
-   * @param {*} stack counter which keeps a tab on nested schemas
-   * @param {*} seenRef References that are repeated. Used to identify circular references.
-   * @param {*} stackLimit Depth to which the schema should be resolved.
+   * @param {*} options.stack counter which keeps a tab on nested schemas
+   * @param {*} options.seenRef References that are repeated. Used to identify circular references.
+   * @param {*} options.stackLimit Depth to which the schema should be resolved.
    * @returns {*} schema - schema that adheres to all individual schemas in schemaArr
    */
-  resolveAllOf: function (schemaArr, parameterSourceOption, components, schemaResolutionCache,
-    resolveFor = 'CONVERSION', resolveTo = 'schema', stack = 0, seenRef, stackLimit) {
+  resolveAllOf: function (schemaArr, parameterSourceOption, components,
+    { resolveFor = 'CONVERSION', resolveTo = 'schema', stack = 0, seenRef = {}, stackLimit = 10, analytics = {} }) {
 
     if (!(schemaArr instanceof Array)) {
       return null;
     }
 
     if (schemaArr.length === 1) {
       // for just one entry in allOf, don't need to enforce type: object restriction
-      return this.resolveRefs(schemaArr[0], parameterSourceOption, components, schemaResolutionCache, resolveFor,
-        resolveTo, stack, seenRef, stackLimit);
+      return this.resolveRefs(schemaArr[0], parameterSourceOption, components,
+        { stack, seenRef: _.cloneDeep(seenRef), resolveFor, resolveTo, stackLimit, analytics });
     }
 
     try {
       return mergeAllOf({
         allOf: schemaArr.map((schema) => {
-          return this.resolveRefs(schema, parameterSourceOption, components, schemaResolutionCache, resolveFor,
-            resolveTo, stack, seenRef, stackLimit, true);
+          return this.resolveRefs(schema, parameterSourceOption, components,
+            { stack, seenRef: _.cloneDeep(seenRef), resolveFor, resolveTo, stackLimit, isAllOf: true, analytics });
         })
       }, {
         resolvers: {
@@ -130,33 +130,35 @@ module.exports = {
 
   /**
    * Resolves references to components for a given schema.
-   * @param {*} schema (openapi) to resolve references.
-   * @param {string} parameterSourceOption tells that the schema object is of request or response
-   * @param {*} components components in openapi spec.
-   * @param {object} schemaResolutionCache stores already resolved references - more structure detail below
-   * {'schema reference key': {
-   *    maxStack {Integer} : Defined as how deep of nesting level we reached while resolving schema that's being cached
-   *    resLevel {Integer} : Defined as nesting level at which schema that's being cached was resolved
-   *    schema {Object} : resolved schema that will be cached
-   * }}
-   * @param {*} resolveFor - resolve refs for validation/conversion (value to be one of VALIDATION/CONVERSION)
-   * @param {string} resolveTo The desired JSON-generation mechanism (schema: prefer using the JSONschema to
+   * @param {*} schema REQUIRED (openapi) to resolve references.
+   * @param {string} parameterSourceOption REQUIRED tells that the schema object is of request or response
+   * @param {*} components REQUIRED components in openapi spec.
+   * @param {object} options REQUIRED a list of options to indicate the type of resolution needed
+   * @param {*} options.resolveFor - resolve refs for validation/conversion (value to be one of VALIDATION/CONVERSION)
+   * @param {string} options.resolveTo The desired JSON-generation mechanism (schema: prefer using the JSONschema to
     generate a fake object, example: use specified examples as-is). Default: schema
-   * @param {*} stack counter which keeps a tab on nested schemas
-   * @param {*} seenRef - References that are repeated. Used to identify circular references.
-   * @param {*} stackLimit Depth to which the schema should be resolved.
-   * @returns {*} schema satisfying JSON-schema-faker.
+   * @param {number} options.stack counter which keeps a tab on nested schemas
+   * @param {*} otions.seenRef - References that are repeated. Used to identify circular references.
+   * @param {number} options.stackLimit Depth to which the schema should be resolved.
+   * @param {Boolean} options.isAllOf
+   * @param {object} options.analytics
+    * @returns {*} schema satisfying JSON-schema-faker.
    */
 
-  resolveRefs: function (schema, parameterSourceOption, components, schemaResolutionCache,
-    resolveFor = 'CONVERSION', resolveTo = 'schema', stack = 0, seenRef = {}, stackLimit = 10, isAllOf = false) {
+  resolveRefs: function (schema, parameterSourceOption, components, {
+    resolveFor = 'CONVERSION', resolveTo = 'schema', stack = 0, seenRef = {}, stackLimit = 10,
+    isAllOf = false, analytics = {}
+  }) {
     var resolvedSchema, prop, splitRef,
       ERR_TOO_MANY_LEVELS = '<Error: Too many levels of nesting to fake this schema>';
     let concreteUtils = components && components.hasOwnProperty('concreteUtils') ?
       components.concreteUtils :
       DEFAULT_SCHEMA_UTILS;
     stack++;
-    schemaResolutionCache = schemaResolutionCache || {};
+
+    if (analytics.actualStack < stack) {
+      analytics.actualStack = stack;
+    }
 
     if (stack > stackLimit) {
       return { value: ERR_TOO_MANY_LEVELS };
@@ -168,23 +170,43 @@ module.exports = {
 
     if (schema.anyOf) {
       if (resolveFor === 'CONVERSION') {
-        return this.resolveRefs(schema.anyOf[0], parameterSourceOption, components, schemaResolutionCache, resolveFor,
-          resolveTo, stack, _.cloneDeep(seenRef), stackLimit);
+        return this.resolveRefs(schema.anyOf[0], parameterSourceOption, components, {
+          resolveFor,
+          resolveTo,
+          stack,
+          seenRef: _.cloneDeep(seenRef),
+          stackLimit,
+          analytics
+        });
       }
       return { anyOf: _.map(schema.anyOf, (schemaElement) => {
         PROPERTIES_TO_ASSIGN_ON_CASCADE.forEach((prop) => {
           if (_.isNil(schemaElement[prop]) && !_.isNil(schema[prop])) {
             schemaElement[prop] = schema[prop];
           }
         });
-        return this.resolveRefs(schemaElement, parameterSourceOption, components, schemaResolutionCache, resolveFor,
-          resolveTo, stack, _.cloneDeep(seenRef), stackLimit);
+        return this.resolveRefs(schemaElement, parameterSourceOption, components,
+          {
+            resolveFor,
+            resolveTo,
+            stack,
+            seenRef: _.cloneDeep(seenRef),
+            stackLimit,
+            analytics
+          });
       }) };
     }
     if (schema.oneOf) {
       if (resolveFor === 'CONVERSION') {
-        return this.resolveRefs(schema.oneOf[0], parameterSourceOption, components, schemaResolutionCache, resolveFor,
-          resolveTo, stack, _.cloneDeep(seenRef), stackLimit);
+        return this.resolveRefs(schema.oneOf[0], parameterSourceOption, components,
+          {
+            resolveFor,
+            resolveTo,
+            stack,
+            seenRef: _.cloneDeep(seenRef),
+            stackLimit,
+            analytics
+          });
       }
       return { oneOf: _.map(schema.oneOf, (schemaElement) => {
         PROPERTIES_TO_ASSIGN_ON_CASCADE.forEach((prop) => {
@@ -193,13 +215,27 @@ module.exports = {
           }
         });
 
-        return this.resolveRefs(schemaElement, parameterSourceOption, components, schemaResolutionCache,
-          resolveFor, resolveTo, stack, _.cloneDeep(seenRef), stackLimit);
+        return this.resolveRefs(schemaElement, parameterSourceOption, components,
+          {
+            resolveFor,
+            resolveTo,
+            stack,
+            seenRef: _.cloneDeep(seenRef),
+            stackLimit,
+            analytics
+          });
       }) };
     }
     if (schema.allOf) {
-      return this.resolveAllOf(schema.allOf, parameterSourceOption, components, schemaResolutionCache, resolveFor,
-        resolveTo, stack, _.cloneDeep(seenRef), stackLimit);
+      return this.resolveAllOf(schema.allOf, parameterSourceOption, components,
+        {
+          resolveFor,
+          resolveTo,
+          stack,
+          seenRef: _.cloneDeep(seenRef),
+          stackLimit,
+          analytics
+        });
     }
     if (schema.$ref && _.isFunction(schema.$ref.split)) {
       let refKey = schema.$ref,
@@ -241,7 +277,14 @@ module.exports = {
       }
       if (resolvedSchema) {
         let refResolvedSchema = this.resolveRefs(resolvedSchema, parameterSourceOption,
-          components, schemaResolutionCache, resolveFor, resolveTo, stack, _.cloneDeep(seenRef), stackLimit);
+          components, {
+            resolveFor,
+            resolveTo,
+            stack,
+            seenRef: _.cloneDeep(seenRef),
+            stackLimit,
+            analytics
+          });
 
         return refResolvedSchema;
       }
@@ -266,7 +309,14 @@ module.exports = {
           }
           else {
             tempSchema.additionalProperties = this.resolveRefs(schema.additionalProperties, parameterSourceOption,
-              components, schemaResolutionCache, resolveFor, resolveTo, stack, _.cloneDeep(seenRef), stackLimit);
+              components, {
+                resolveFor,
+                resolveTo,
+                stack,
+                seenRef: _.cloneDeep(seenRef),
+                stackLimit,
+                analytics
+              });
           }
         }
 
@@ -300,7 +350,14 @@ module.exports = {
             tempSchema.properties[prop] = _.isEmpty(property) ?
               {} :
               this.resolveRefs(property, parameterSourceOption, components,
-                schemaResolutionCache, resolveFor, resolveTo, stack, _.cloneDeep(seenRef), stackLimit);
+                {
+                  resolveFor,
+                  resolveTo,
+                  stack,
+                  seenRef: _.cloneDeep(seenRef),
+                  stackLimit,
+                  analytics
+                });
           }
         }
         return tempSchema;
@@ -339,7 +396,14 @@ module.exports = {
       let tempSchema = _.omit(schema, ['items', 'additionalProperties']);
 
       tempSchema.items = this.resolveRefs(schema.items, parameterSourceOption,
-        components, schemaResolutionCache, resolveFor, resolveTo, stack, _.cloneDeep(seenRef), stackLimit);
+        components, {
+          resolveFor,
+          resolveTo,
+          stack,
+          seenRef: _.cloneDeep(seenRef),
+          stackLimit,
+          analytics
+        });
       return tempSchema;
     }
     else if (!schema.hasOwnProperty('default')) {