Merge branch 'release/4.10.0'

Author: VShingala

CHANGELOG.md

@@ -1,5 +1,10 @@
 # OpenAPI-Postman Changelog
 
+#### v4.10.0 (March 08, 2023)
+* Added support for convertV2() interface which has more stacklimit for schema resolution.
+* Added support for validateTransactionV2() interface uses same v2 interface for resolving schema.
+* Fixed multiple issues for urlencoded body with anyOf and oneOf schemas where valid data was reported as mismatches.
+
 #### v4.9.0 (February 06, 2023)
 * Fixed issue [#660](https://github.com/postmanlabs/openapi-to-postman/issues/660) where for certain XML request bodies, conversion was failing with TypeError.
 * Fixed issue where for some definitions having non-string URLs were failing conversion with TypeErrors.

OPTIONS.md

@@ -6,6 +6,8 @@ collapseFolders|boolean|-|true|Importing will collapse all folders that have onl
 optimizeConversion|boolean|-|true|Optimizes conversion for large specification, disabling this option might affect the performance of conversion.|CONVERSION
 requestParametersResolution|enum|Example, Schema|Schema|Select whether to generate the request parameters based on the [schema](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#schemaObject) or the [example](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#exampleObject) in the schema.|CONVERSION
 exampleParametersResolution|enum|Example, Schema|Example|Select whether to generate the response parameters based on the [schema](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#schemaObject) or the [example](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#exampleObject) in the schema.|CONVERSION
+disabledParametersValidation|boolean|-|true|Whether disabled parameters of collection should be validated|VALIDATION
+parametersResolution|enum|Example, Schema|Schema|Select whether to generate the request and response parameters based on the [schema](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#schemaObject) or the [example](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#exampleObject) in the schema.|CONVERSION
 folderStrategy|enum|Paths, Tags|Paths|Select whether to create folders according to the spec’s paths or tags.|CONVERSION
 schemaFaker|boolean|-|true|Whether or not schemas should be faked.|CONVERSION
 stackLimit|integer|-|10|Number of nesting limit till which schema resolution will happen. Increasing this limit may result in more time to convert collection depending on complexity of specification. (To make sure this option works correctly "optimizeConversion" option needs to be disabled)|CONVERSION

assets/json-schema-faker.js

@@ -23468,7 +23468,12 @@ function extend() {
           var context = {};
           while (length--) {
               var fn = keys[length].replace(/^x-/, '');
-              var gen = this.support[fn];
+
+              /**
+               * CHANGE: This Makes sure that we're not using Object's prototype properties,
+               * while accessing certain keys like 'constructor'
+               */
+              var gen = this.support.hasOwnProperty(fn) && this.support[fn];
               if (typeof gen === 'function') {
                 if (typeof schema[fn] === 'object' && schema[fn].hasOwnProperty('type')) {
                   continue;
@@ -23814,6 +23819,14 @@ function extend() {
       }
       // execute generator
       var value = callback(params);
+
+      /**
+       * CHANGE: This Makes sure that we're not typecasting null to "null"
+       */
+      if (_.get(schema, 'nullable') && value === null) {
+        return value;
+      }
+
       // normalize output value
       switch (schema.type) {
           case 'number':
@@ -23830,7 +23843,11 @@ function extend() {
               var min = Math.max(params.minLength || 0, 0);
               var max = Math.min(params.maxLength || Infinity, Infinity);
               while (value.length < min) {
-                  value += ' ' + value;
+                  /**
+                   * CHANGE: This Makes sure that we're not adding extra spaces in generated value,
+                   * As such behaviour generates invalid data when pattern is mentioned.
+                   */
+                  value += (schema.pattern ? '' : ' ') + value;
               }
               if (value.length > max) {
                   value = value.substr(0, max);
@@ -24236,24 +24253,24 @@ function extend() {
   // Updated objectType definition to latest version (0.5.0-rcv.41)
   var objectType = function objectType(value, path, resolve, traverseCallback, seenSchemaCache) {
     const props = {};
-  
+
     const properties = value.properties || {};
     const patternProperties = value.patternProperties || {};
     const requiredProperties = typeof value.required === 'boolean' ? [] : (value.required || []).slice();
     const allowsAdditional = value.additionalProperties !== false;
-  
+
     const propertyKeys = Object.keys(properties);
     const patternPropertyKeys = Object.keys(patternProperties);
     const optionalProperties = propertyKeys.concat(patternPropertyKeys).reduce((_response, _key) => {
       if (requiredProperties.indexOf(_key) === -1) _response.push(_key);
       return _response;
     }, []);
     const allProperties = requiredProperties.concat(optionalProperties);
-  
+
     const additionalProperties = allowsAdditional // eslint-disable-line
       ? (value.additionalProperties === true ? anyType : value.additionalProperties)
       : value.additionalProperties;
-  
+
     if (!allowsAdditional
       && propertyKeys.length === 0
       && patternPropertyKeys.length === 0
@@ -24262,50 +24279,50 @@ function extend() {
       // just nothing
       return null;
     }
-  
+
     if (optionAPI('requiredOnly') === true) {
       requiredProperties.forEach(key => {
         if (properties[key]) {
           props[key] = properties[key];
         }
       });
-  
+
       return traverseCallback(props, path.concat(['properties']), resolve, value, seenSchemaCache);
     }
-  
+
     const optionalsProbability = optionAPI('alwaysFakeOptionals') === true ? 1.0 : optionAPI('optionalsProbability');
     const fixedProbabilities = optionAPI('alwaysFakeOptionals') || optionAPI('fixedProbabilities') || false;
     const ignoreProperties = optionAPI('ignoreProperties') || [];
     const reuseProps = optionAPI('reuseProperties');
     const fillProps = optionAPI('fillProperties');
-  
+
     const max = value.maxProperties || (allProperties.length + (allowsAdditional ? random.number(1, 5) : 0));
-  
+
     let min = Math.max(value.minProperties || 0, requiredProperties.length);
     let neededExtras = Math.max(0, allProperties.length - min);
-  
+
     if (optionalsProbability !== null) {
       if (fixedProbabilities === true) {
         neededExtras = Math.round((min - requiredProperties.length) + (optionalsProbability * (allProperties.length - min)));
       } else {
         neededExtras = random.number(min - requiredProperties.length, optionalsProbability * (allProperties.length - min));
       }
     }
-  
+
     const extraPropertiesRandomOrder = random.shuffle(optionalProperties).slice(0, neededExtras);
     const extraProperties = optionalProperties.filter(_item => {
       return extraPropertiesRandomOrder.indexOf(_item) !== -1;
     });
-  
+
     // properties are read from right-to-left
     const _limit = optionalsProbability !== null || requiredProperties.length === max ? max : random.number(0, max);
     const _props = requiredProperties.concat(extraProperties).slice(0, max);
     const _defns = [];
-  
+
     if (value.dependencies) {
       Object.keys(value.dependencies).forEach(prop => {
         const _required = value.dependencies[prop];
-  
+
         if (_props.indexOf(prop) !== -1) {
           if (Array.isArray(_required)) {
             // property-dependencies
@@ -24319,20 +24336,20 @@ function extend() {
           }
         }
       });
-  
+
       // schema-dependencies
       if (_defns.length) {
         delete value.dependencies;
-  
+
         return traverseCallback({
           allOf: _defns.concat(value),
         }, path.concat(['properties']), resolve, value, seenSchemaCache);
       }
     }
-  
+
     const skipped = [];
     const missing = [];
-  
+
     _props.forEach(key => {
       for (let i = 0; i < ignoreProperties.length; i += 1) {
         if ((ignoreProperties[i] instanceof RegExp && ignoreProperties[i].test(key))
@@ -24342,38 +24359,38 @@ function extend() {
           return;
         }
       }
-  
+
       if (additionalProperties === false) {
         if (requiredProperties.indexOf(key) !== -1) {
           props[key] = properties[key];
         }
       }
-  
+
       if (properties[key]) {
         props[key] = properties[key];
       }
-  
+
       let found;
-  
+
       // then try patternProperties
       patternPropertyKeys.forEach(_key => {
         if (key.match(new RegExp(_key))) {
           found = true;
-  
+
           if (props[key]) {
             utils.merge(props[key], patternProperties[_key]);
           } else {
             props[random.randexp(key)] = patternProperties[_key];
           }
         }
       });
-  
+
       if (!found) {
         // try patternProperties again,
         const subschema = patternProperties[key] || additionalProperties;
-  
+
         // FIXME: allow anyType as fallback when no subschema is given?
-  
+
         if (subschema && additionalProperties !== false) {
           // otherwise we can use additionalProperties?
           props[patternProperties[key] ? random.randexp(key) : key] = properties[key] || subschema;
@@ -24382,103 +24399,103 @@ function extend() {
         }
       }
     });
-  
+
     // discard already ignored props if they're not required to be filled...
     let current = Object.keys(props).length + (fillProps ? 0 : skipped.length);
-  
+
     // generate dynamic suffix for additional props...
     const hash = suffix => random.randexp(`_?[_a-f\\d]{1,3}${suffix ? '\\$?' : ''}`);
-  
+
     function get(from) {
       let one;
-  
+
       do {
         if (!from.length) break;
         one = from.shift();
       } while (props[one]);
-  
+
       return one;
     }
-  
+
     let minProps = min;
     if (allowsAdditional && !requiredProperties.length) {
       minProps = Math.max(optionalsProbability === null || additionalProperties ? random.number(fillProps ? 1 : 0, max) : 0, min);
     }
-  
+
     while (fillProps) {
       if (!(patternPropertyKeys.length || allowsAdditional)) {
         break;
       }
-  
+
       if (current >= minProps) {
         break;
       }
-  
+
       if (allowsAdditional) {
         if (reuseProps && ((propertyKeys.length - current) > minProps)) {
           let count = 0;
           let key;
-  
+
           do {
             count += 1;
-  
+
             // skip large objects
             if (count > 1000) {
               break;
             }
-  
+
             key = get(requiredProperties) || random.pick(propertyKeys);
           } while (typeof props[key] !== 'undefined');
-  
+
           if (typeof props[key] === 'undefined') {
             props[key] = properties[key];
             current += 1;
           }
         } else if (patternPropertyKeys.length && !additionalProperties) {
           const prop = random.pick(patternPropertyKeys);
           const word = random.randexp(prop);
-  
+
           if (!props[word]) {
             props[word] = patternProperties[prop];
             current += 1;
           }
         } else {
           const word = get(requiredProperties) || (wordsGenerator(1) + hash());
-  
+
           if (!props[word]) {
             props[word] = additionalProperties || anyType;
             current += 1;
           }
         }
       }
-  
+
       for (let i = 0; current < min && i < patternPropertyKeys.length; i += 1) {
         const _key = patternPropertyKeys[i];
         const word = random.randexp(_key);
-  
-  
+
+
         if (!props[word]) {
           props[word] = patternProperties[_key];
           current += 1;
         }
       }
     }
-  
+
     // fill up-to this value and no more!
     if (requiredProperties.length === 0 && (!allowsAdditional || optionalsProbability === false)) {
       const maximum = random.number(min, max);
-  
+
       for (; current < maximum;) {
         const word = get(propertyKeys);
-  
+
         if (word) {
           props[word] = properties[word];
         }
-  
+
         current += 1;
       }
     }
-  
+
     return traverseCallback(props, path.concat(['properties']), resolve, value, seenSchemaCache);
   };
 
@@ -24571,7 +24588,11 @@ function extend() {
 
       // types from draft-0[67] (?)
       'uri-reference': `${URI_PATTERN}${PARAM_PATTERN}`,
-      'uri-template': URI_PATTERN.replace('(?:', '(?:/\\{[a-z][:a-zA-Z0-9-]*\\}|'),
+      /**
+       * CHANGE: Corrected uri-template format to be inline with RFC-6570
+       * https://www.rfc-editor.org/rfc/rfc6570#section-2
+       */
+      'uri-template': URI_PATTERN.replace('(?:', '(?:/\\{[a-z][a-zA-Z0-9]*\\}|'),
       'json-pointer': `(/(?:${FRAGMENT.replace(']*', '/]*')}|~[01]))+`,
 
       // some types from https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#data-types (?)

index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { MODULE_VERSION } = require('./lib/schemapack.js');
+
 const _ = require('lodash'),
   SchemaPack = require('./lib/schemapack.js').SchemaPack;
 
@@ -14,6 +16,16 @@ module.exports = {
     return cb(null, schema.validationResult);
   },
 
+  convertV2: function(input, options, cb) {
+    var schema = new SchemaPack(input, options, MODULE_VERSION.V2);
+
+    if (schema.validated) {
+      return schema.convertV2(cb);
+    }
+
+    return cb(null, schema.validationResult);
+  },
+
   validate: function (input) {
     var schema = new SchemaPack(input);
     return schema.validationResult;