Merge pull request #895 from postmanlabs/release/v5.3.4

Release version v5.3.4

Author: barshan23

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## [Unreleased]
 
+## [v5.3.4] - 2025-11-06
+
 ## [v5.3.3] - 2025-10-14
 
 ## [v5.3.2] - 2025-10-08
@@ -671,7 +673,9 @@ Newer releases follow the [Keep a Changelog](https://keepachangelog.com/en/1.0.0
 
 -   Base release
 
-[Unreleased]: https://github.com/postmanlabs/openapi-to-postman/compare/v5.3.3...HEAD
+[Unreleased]: https://github.com/postmanlabs/openapi-to-postman/compare/v5.3.4...HEAD
+
+[v5.3.4]: https://github.com/postmanlabs/openapi-to-postman/compare/v5.3.3...v5.3.4
 
 [v5.3.3]: https://github.com/postmanlabs/openapi-to-postman/compare/v5.3.2...v5.3.3
 

assets/json-schema-faker.js

@@ -24820,6 +24820,18 @@ function extend() {
               }
           }
       }
+
+      if (!type && path[path.length - 1] !== 'properties' && path[path.length - 1] !== 'items') {
+        // This is needed to handle the <Circular reference to schema> and <Error too many levels of nesting> case
+        // As those error values needs to be returned as is
+        if (typeof _.get(schema, 'value') === 'string') {
+          return schema;
+        }
+
+        // We're not able to determine the type, return empty string
+        return '';
+      }
+
       var copy = {};
       if (Array.isArray(schema)) {
           copy = [];

libV2/schemaUtils.js

@@ -753,9 +753,16 @@ let QUERYPARAM = 'query',
     }
 
     if (schema.hasOwnProperty('additionalProperties')) {
-      schema.additionalProperties = _.isBoolean(schema.additionalProperties) ? schema.additionalProperties :
-        _resolveSchema(context, schema.additionalProperties, stack, resolveFor, _.cloneDeep(seenRef),
-          utils.addToJsonPath(currentPath, ['additionalProperties']));
+      // _.isEmpty check is needed to handle the case where additional properties is set as empty object.
+      // which is valid as per OAS and means that additional properties are allowed (i.e it is equivalent to true)
+      if (_.isBoolean(schema.additionalProperties) || _.isEmpty(schema.additionalProperties)) {
+        schema.additionalProperties = Boolean(schema.additionalProperties);
+      }
+      else {
+        schema.additionalProperties = _resolveSchema(context, schema.additionalProperties, stack, resolveFor,
+          _.cloneDeep(seenRef), utils.addToJsonPath(currentPath, ['additionalProperties']));
+      }
+
       schema.type = schema.type || SCHEMA_TYPES.object;
     }
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "openapi-to-postmanv2",
-  "version": "5.3.3",
+  "version": "5.3.4",
   "description": "Convert a given OpenAPI specification to Postman Collection v2.0",
   "homepage": "https://github.com/postmanlabs/openapi-to-postman",
   "bugs": "https://github.com/postmanlabs/openapi-to-postman/issues",

package.json

@@ -69,7 +69,7 @@ describe('convertV2WithTypes should generate collection conforming to collection
 
   it('should validate parameters of the collection', function (done) {
     const openapi = fs.readFileSync(testSpec1, 'utf8'),
-      options = { schemaFaker: true, exampleParametersResolution: 'schema' };
+      options = { schemaFaker: true, parametersResolution: 'schema' };
 
     Converter.convertV2WithTypes({ type: 'string', data: openapi }, options, (err, conversionResult) => {
       expect(err).to.be.null;
@@ -90,7 +90,7 @@ describe('convertV2WithTypes should generate collection conforming to collection
       expect(createPet.request.method).to.equal('POST');
       expect(idDescription).to.equal('The id of the pet to retrieve');
       expect(createPet.request.body.mode).to.equal('raw');
-      expect(createPet.request.body.raw).to.include('request body comes here');
+      expect(createPet.request.body.raw).to.equal('');
 
       const queryParams = listAllPets.request.url.query;
       expect(queryParams).to.be.an('array').that.has.length(3);
@@ -114,6 +114,29 @@ describe('convertV2WithTypes should generate collection conforming to collection
     );
   });
 
+  it('should pick example value for request body parametersResolution=Example', function (done) {
+    const openapi = fs.readFileSync(testSpec1, 'utf8'),
+      options = { schemaFaker: true, parametersResolution: 'Example' };
+
+    Converter.convertV2WithTypes({ type: 'string', data: openapi }, options, (err, conversionResult) => {
+      expect(err).to.be.null;
+      expect(conversionResult.output).to.be.an('array').that.is.not.empty;
+
+      const firstFolder = conversionResult.output[0].data.item[0];
+      expect(firstFolder).to.have.property('name', 'pets');
+
+      const listAllPets = firstFolder.item[0];
+      expect(listAllPets).to.have.property('name', 'List all pets');
+      expect(listAllPets.request.method).to.equal('GET');
+
+      const createPet = firstFolder.item[1];
+      expect(createPet.request.body.mode).to.equal('raw');
+      expect(createPet.request.body.raw).to.equal('request body comes here');
+
+      done();
+    });
+  });
+
   it('Should generate collection conforming to schema for and fail if not valid ' +
     testSpec1, function(done) {
     Converter.convertV2WithTypes(
@@ -174,6 +197,194 @@ describe('convertV2WithTypes', function() {
       });
   });
 
+  it('should handle non existent type in parameter schema', function(done) {
+    const oas = {
+      openapi: '3.0.0',
+      info: { title: 'Form Explode Deprecated Test', version: '1.0.0' },
+      paths: {
+        '/pets': {
+          get: {
+            parameters: [
+              {
+                name: 'qp',
+                in: 'query',
+                schema: { deprecated: true }
+              }
+            ],
+            responses: { '200': { description: 'ok' } }
+          }
+        }
+      }
+    };
+
+    Converter.convertV2WithTypes({ type: 'json', data: oas }, {
+      parametersResolution: 'Example'
+    }, (err, conversionResult) => {
+      expect(err).to.be.null;
+      expect(conversionResult.result).to.equal(true);
+
+      const items = conversionResult.output[0].data.item;
+      const request = items[0].item[0].request;
+      const query = request.url.query;
+
+      expect(query.length).to.be.equal(1);
+      expect(query[0].key).to.equal('qp');
+      expect(query[0].value).to.equal('');
+      done();
+    });
+  });
+
+  it('should handle schemas with unavailable types properly with parametersResolution=Example', function(done) {
+    const oas = {
+      openapi: '3.0.0',
+      info: { title: 'DeepObject Deprecated Test', version: '1.0.0' },
+      paths: {
+        '/pets': {
+          post: {
+            parameters: [
+              {
+                name: 'qp',
+                in: 'query',
+                style: 'deepObject',
+                explode: true,
+                schema: {
+                  type: 'object',
+                  deprecated: true,
+                  properties: {
+                    name: {
+                      description: 'Name of the pet'
+                    }
+                  }
+                }
+              }
+            ],
+            requestBody: {
+              content: {
+                'application/json': {
+                  schema: {
+                    deprecated: false,
+                    description: 'Help',
+                    // Type is not defined here
+                    properties: {
+                      name: { type: 'string' },
+                      style: {
+                        type: 'array',
+                        items: {
+                          anyOf: [
+                            { type: 'string' },
+                            { type: 'number' }
+                          ]
+                        }
+                      },
+                      age: {
+                        // type not defined here
+                        description: 'age'
+
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            responses: { '200': { description: 'ok' } }
+          }
+        }
+      }
+    };
+
+    Converter.convertV2WithTypes({ type: 'json', data: oas }, {
+      parametersResolution: 'Example'
+    }, (err, conversionResult) => {
+      expect(err).to.be.null;
+      expect(conversionResult.result).to.equal(true);
+
+      const items = conversionResult.output[0].data.item;
+      const request = items[0].item[0].request;
+      const query = request.url.query || [];
+
+      expect(query.length).to.be.equal(1);
+      expect(query[0].key).to.equal('qp[name]');
+      expect(query[0].value).to.equal('');
+
+      expect(request.body.raw).to.be.equal('{\n  "name": "string",\n  "style": [\n    "string",\n    "string"\n  ],\n  "age": ""\n}');
+
+      done();
+    });
+  });
+
+  it('should handle schemas with unavailable types properly with parametersResolution=Schema', function(done) {
+    const oas = {
+      openapi: '3.0.0',
+      info: { title: 'DeepObject Deprecated Test', version: '1.0.0' },
+      paths: {
+        '/pets': {
+          post: {
+            parameters: [
+              {
+                name: 'qp',
+                in: 'query',
+                style: 'deepObject',
+                explode: true,
+                schema: {
+                  type: 'object',
+                  deprecated: true,
+                  properties: {
+                    name: {
+                      description: 'Name of the pet'
+                    }
+                  }
+                }
+              }
+            ],
+            requestBody: {
+              content: {
+                'application/json': {
+                  schema: {
+                    deprecated: false,
+                    description: 'Help',
+                    properties: {
+                      name: { type: 'string' },
+                      style: {
+                        type: 'array',
+                        items: {
+                          anyOf: [
+                            { type: 'string' },
+                            { type: 'number' }
+                          ]
+                        }
+                      },
+                      age: { description: 'age' }
+                    }
+                  }
+                }
+              }
+            },
+            responses: { '200': { description: 'ok' } }
+          }
+        }
+      }
+    };
+
+    Converter.convertV2WithTypes({ type: 'json', data: oas }, {
+      parametersResolution: 'Schema'
+    }, (err, conversionResult) => {
+      expect(err).to.be.null;
+      expect(conversionResult.result).to.equal(true);
+
+      const items = conversionResult.output[0].data.item;
+      const request = items[0].item[0].request;
+      const query = request.url.query || [];
+
+      expect(query.length).to.be.equal(1);
+      expect(query[0].key).to.equal('qp[name]');
+      expect(query[0].value).to.equal('');
+
+      expect(request.body.raw).to.be.equal('{\n  "name": "<string>",\n  "style": [\n    "<string>",\n    "<string>"\n  ],\n  "age": ""\n}');
+
+      done();
+    });
+  });
+
   it('should resolve nested array and object schema types correctly in extractedTypes', function(done) {
     const example = {
         name: 'Buddy',
@@ -189,7 +400,7 @@ describe('convertV2WithTypes', function() {
         }
       },
       openapi = fs.readFileSync(readOnlyNestedSpec, 'utf8'),
-      options = { schemaFaker: true, exampleParametersResolution: 'schema' };
+      options = { schemaFaker: true, parametersResolution: 'schema' };
 
     Converter.convertV2WithTypes({ type: 'string', data: openapi }, options, (err, conversionResult) => {
       expect(err).to.be.null;
@@ -281,7 +492,7 @@ describe('convertV2WithTypes', function() {
         }
       },
       openapi = fs.readFileSync(testSpec1, 'utf8'),
-      options = { schemaFaker: true, exampleParametersResolution: 'schema' };
+      options = { schemaFaker: true, parametersResolution: 'schema' };
 
     Converter.convertV2WithTypes({ type: 'string', data: openapi }, options, (err, conversionResult) => {
       expect(err).to.be.null;
@@ -988,7 +1199,7 @@ describe('convertV2WithTypes', function() {
 
   it('types should contain title and description', function(done) {
     const openapi = fs.readFileSync(testSpec2, 'utf8'),
-      options = { schemaFaker: true, exampleParametersResolution: 'schema' };
+      options = { schemaFaker: true, parametersResolution: 'schema' };
 
     Converter.convertV2WithTypes({ type: 'string', data: openapi }, options, (err, conversionResult) => {
       expect(err).to.be.null;