Release version v5.2.0 (#869)

* Enhance  type fetching to support composite schemas (anyOf, oneOf, allOf)

* Refactor type fetching logic to process original schema before modifications

* Update parameter resolution logic to handle 'PROCESSING' state in schema conversion

* Refactor schema processing to conditionally push resolved schema types for 'PROCESSING' state

* Add support for composite schemas (anyOf, oneOf, allOf) in conversion process

* schema changes for 2-way-sync

* fixed test

* Enhance composite schema tests to validate specific structures for anyOf cases

* removed examples

* Refactor ESLint rules and remove unnecessary one-var disables; enhance schema resolution logic for composite parameters in conversion tests (#868)

Refactor ESLint rules and remove unnecessary one-var disables; enhance schema resolution logic for composite parameters in conversion tests (#868)

* added deprecated example

* added test for description

* Resolved comments

* Bug Fixes

* refactored

* Prepare release v5.2.0

---------

Co-authored-by: Avishek Saha <[email protected]>
Co-authored-by: barshan23 <[email protected]>
Co-authored-by: Ayush Shrivastav <[email protected]>
Co-authored-by: GitHub Actions <[email protected]>

Author: 4 people

.eslintrc

@@ -195,7 +195,6 @@
       "no-unneeded-ternary": "error",
       "no-whitespace-before-property": "error",
       "object-curly-spacing": ["error", "always"],
-      "one-var": ["error", "always"],
       "one-var-declaration-per-line": "error",
       "operator-assignment": "error",
       "operator-linebreak": ["error", "after"],

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## [Unreleased]
 
+## [v5.2.0] - 2025-09-19
+
 ## [v5.1.0] - 2025-09-01
 
 ## [v5.0.2] - 2025-08-25
@@ -661,7 +663,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.1.0...HEAD
+[Unreleased]: https://github.com/postmanlabs/openapi-to-postman/compare/v5.2.0...HEAD
+
+[v5.2.0]: https://github.com/postmanlabs/openapi-to-postman/compare/v5.1.0...v5.2.0
 
 [v5.1.0]: https://github.com/postmanlabs/openapi-to-postman/compare/v5.0.2...v5.1.0
 

libV2/index.js

@@ -1,4 +1,3 @@
-/* eslint-disable one-var */
 const _ = require('lodash'),
   { Collection } = require('postman-collection/lib/collection/collection'),
   GraphLib = require('graphlib'),

libV2/schemaUtils.js

@@ -128,6 +128,7 @@ schemaFaker.option({
 
 let QUERYPARAM = 'query',
   CONVERSION = 'conversion',
+  TYPES_GENERATION = 'typesGeneration',
   HEADER = 'header',
   PATHPARAM = 'path',
   SCHEMA_TYPES = {
@@ -493,6 +494,30 @@ let QUERYPARAM = 'query',
    * @returns {Object} Resolved schema
    */
   resolveAllOfSchema = (context, schema, stack = 0, resolveFor = CONVERSION, seenRef = {}, currentPath = '') => {
+    /*
+      For TYPES_GENERATION, we do not want to merge the allOf schemas
+      instead we want to keep them separate so that we can generate types like:
+      allOf: [
+        { $ref: '#/components/schemas/User' },
+        {
+          type: 'object',
+          properties: {
+            timestamp: { type: 'string', format: 'date-time' }
+          }
+        }
+      ]
+      If we merge the schemas, we will loose the information that the schema was
+      a combination of multiple schemas
+    */
+    if (resolveFor === TYPES_GENERATION) {
+      return {
+        allOf: _.map(schema.allOf, (schema) => {
+          // eslint-disable-next-line no-use-before-define
+          return _resolveSchema(context, schema, stack, resolveFor, _.cloneDeep(seenRef), currentPath);
+        })
+      };
+    }
+
     try {
       return mergeAllOf(_.assign(schema, {
         allOf: _.map(schema.allOf, (schema) => {
@@ -543,7 +568,6 @@ let QUERYPARAM = 'query',
 
     stack++;
 
-    // eslint-disable-next-line one-var
     const compositeKeyword = schema.anyOf ? 'anyOf' : 'oneOf',
       { concreteUtils } = context;
 
@@ -618,7 +642,6 @@ let QUERYPARAM = 'query',
           writeOnlyPropCache: context.writeOnlyPropCache
         };
 
-        // eslint-disable-next-line one-var
         const newReadPropCache = context.readOnlyPropCache,
           newWritePropCache = context.writeOnlyPropCache;
 
@@ -684,7 +707,7 @@ let QUERYPARAM = 'query',
         let { parametersResolution } = context.computedOptions;
 
         // Override default value to schema for CONVERSION only for parmeter resolution set to schema
-        if (resolveFor === CONVERSION && parametersResolution === 'schema') {
+        if ((resolveFor === CONVERSION || resolveFor === TYPES_GENERATION) && parametersResolution === 'schema') {
           if (!schema.hasOwnProperty('format')) {
             schema.default = '<' + schema.type + '>';
           }
@@ -743,16 +766,42 @@ let QUERYPARAM = 'query',
  * @returns {Object} The processed schema details.
  */
   processSchema = (resolvedSchema) => {
+    if (resolvedSchema.anyOf) {
+      return {
+        anyOf: resolvedSchema.anyOf.map((schema) => {
+          return processSchema(schema);
+        })
+      };
+    }
+
+    if (resolvedSchema.oneOf) {
+      return {
+        oneOf: resolvedSchema.oneOf.map((schema) => {
+          return processSchema(schema);
+        })
+      };
+    }
+
+    if (resolvedSchema.allOf) {
+      return {
+        allOf: resolvedSchema.allOf.map((schema) => {
+          return processSchema(schema);
+        })
+      };
+    }
+
     if (resolvedSchema.type === 'object' && resolvedSchema.properties) {
       const schemaDetails = {
+          description: resolvedSchema.description,
+          title: resolvedSchema.title,
           type: resolvedSchema.type,
           properties: {},
           required: []
         },
         requiredProperties = new Set(resolvedSchema.required || []);
 
       for (let [propName, propValue] of Object.entries(resolvedSchema.properties)) {
-        if (!propValue.type) {
+        if (!propValue.type && !propValue.anyOf && !propValue.oneOf && !propValue.allOf) {
           continue;
         }
         const propertyDetails = {
@@ -772,7 +821,23 @@ let QUERYPARAM = 'query',
         if (requiredProperties.has(propName)) {
           schemaDetails.required.push(propName);
         }
-        if (propValue.properties) {
+
+        if (propValue.anyOf) {
+          propertyDetails.anyOf = propValue.anyOf.map((schema) => {
+            return processSchema(schema);
+          });
+        }
+        else if (propValue.oneOf) {
+          propertyDetails.oneOf = propValue.oneOf.map((schema) => {
+            return processSchema(schema);
+          });
+        }
+        else if (propValue.allOf) {
+          propertyDetails.allOf = propValue.allOf.map((schema) => {
+            return processSchema(schema);
+          });
+        }
+        else if (propValue.properties) {
           let processedProperties = processSchema(propValue);
           propertyDetails.properties = processedProperties.properties;
           if (processedProperties.required) {
@@ -1113,16 +1178,24 @@ let QUERYPARAM = 'query',
    * Gets the description of the parameter.
    * If the parameter is required, it prepends a `(Requried)` before the parameter description
    * If the parameter type is enum, it appends the possible enum values
+   * @param {object} context - Global context object controlling behavior
    * @param {object} parameter - input param for which description needs to be returned
    * @returns {string} description of the parameters
    */
-  getParameterDescription = (parameter) => {
+  getParameterDescription = (context, parameter) => {
     if (!_.isObject(parameter)) {
       return '';
     }
 
-    return (parameter.required ? '(Required) ' : '') + (parameter.description || '') +
-      (parameter.enum ? ' (This can only be one of ' + parameter.enum + ')' : '');
+    const requiredPrefix = (context && !context.enableTypeFetching && parameter.required ? '(Required) ' : ''),
+      desc = parameter.description || '';
+
+    let enumDescription = '';
+    if (parameter && parameter.schema && parameter.schema.enum && !(context && context.enableTypeFetching)) {
+      enumDescription = ' (This can only be one of ' + parameter.schema.enum + ')';
+    }
+
+    return requiredPrefix + desc + enumDescription;
   },
 
   /**
@@ -1141,7 +1214,7 @@ let QUERYPARAM = 'query',
       { enableOptionalParameters } = context.computedOptions;
 
     let serialisedValue = '',
-      description = getParameterDescription(param),
+      description = getParameterDescription(context, param),
       paramName = _.get(param, 'name'),
       disabled = !enableOptionalParameters && _.get(param, 'required') !== true,
       pmParams = [],
@@ -1421,7 +1494,6 @@ let QUERYPARAM = 'query',
       });
     });
 
-    // eslint-disable-next-line one-var
     let responseExample,
       responseExampleData;
 
@@ -1482,6 +1554,21 @@ let QUERYPARAM = 'query',
       return [{ [bodyKey]: bodyData }];
     }
 
+    // For type fetching, process the original schema before any modifications
+    // This is done to preserve the anyOf, oneOf etc in the original schema
+    // since they are otherwise flattened while resolving the schema
+    if (context.enableTypeFetching && requestBodySchema) {
+      const originalSchema = requestBodySchema.schema || requestBodySchema,
+        resolvedSchema = resolveSchema(
+          context,
+          originalSchema,
+          { resolveFor: TYPES_GENERATION });
+
+      if (resolvedSchema.type || resolvedSchema.anyOf || resolvedSchema.oneOf || resolvedSchema.allOf) {
+        resolvedSchemaTypes.push(processSchema(resolvedSchema));
+      }
+    }
+
     if (requestBodySchema.$ref) {
       requestBodySchema = resolveSchema(
         context,
@@ -1611,11 +1698,6 @@ let QUERYPARAM = 'query',
 
     }
 
-    if (context.enableTypeFetching && requestBodySchema.type !== undefined) {
-      const requestBodySchemaTypes = processSchema(requestBodySchema);
-      resolvedSchemaTypes.push(requestBodySchemaTypes);
-    }
-
     // Generate multiple examples when either request or response contains more than one example
     if (
       isExampleBody &&
@@ -1772,7 +1854,7 @@ let QUERYPARAM = 'query',
       paramSchema.required = _.has(paramSchema, 'required') ?
         paramSchema.required :
         _.indexOf(requestBodySchema.required, key) !== -1;
-      description = getParameterDescription(paramSchema);
+      description = getParameterDescription(context, paramSchema);
 
       if (typeof _.get(encoding, `[${key}].contentType`) === 'string') {
         contentType = encoding[key].contentType;
@@ -2027,8 +2109,8 @@ let QUERYPARAM = 'query',
       type: schema.type,
       format: schema.format,
       default: schema.default,
-      required: param.required || false,
-      deprecated: param.deprecated || false,
+      required: param.required,
+      deprecated: param.deprecated,
       enum: schema.enum || undefined,
       minLength: schema.minLength,
       maxLength: schema.maxLength,
@@ -2054,14 +2136,18 @@ let QUERYPARAM = 'query',
         param = resolveSchema(context, param);
       }
 
-      if (_.has(param.schema, '$ref')) {
-        param.schema = resolveSchema(context, param.schema);
-      }
-
       if (param.in !== QUERYPARAM || (!includeDeprecated && param.deprecated)) {
         return;
       }
 
+      const shouldResolveSchema = _.has(param, 'schema') &&
+        (_.has(param.schema, '$ref') || _.has(param.schema, 'anyOf') ||
+          _.has(param.schema, 'oneOf') || _.has(param.schema, 'allOf'));
+
+      if (shouldResolveSchema) {
+        param.schema = resolveSchema(context, param.schema);
+      }
+
       let queryParamTypeInfo = {},
         properties = {},
         paramValue = resolveValueOfParameter(context, param);
@@ -2103,14 +2189,19 @@ let QUERYPARAM = 'query',
         param = resolveSchema(context, param);
       }
 
-      if (_.has(param.schema, '$ref')) {
-        param.schema = resolveSchema(context, param.schema);
-      }
-
       if (param.in !== PATHPARAM) {
         return;
       }
 
+
+      const shouldResolveSchema = _.has(param, 'schema') &&
+        (_.has(param.schema, '$ref') || _.has(param.schema, 'anyOf') ||
+          _.has(param.schema, 'oneOf') || _.has(param.schema, 'allOf'));
+
+      if (shouldResolveSchema) {
+        param.schema = resolveSchema(context, param.schema);
+      }
+
       let pathParamTypeInfo = {},
         properties = {},
         paramValue = resolveValueOfParameter(context, param);
@@ -2180,14 +2271,18 @@ let QUERYPARAM = 'query',
         param = resolveSchema(context, param);
       }
 
-      if (_.has(param.schema, '$ref')) {
-        param.schema = resolveSchema(context, param.schema);
-      }
-
       if (param.in !== HEADER || (!includeDeprecated && param.deprecated)) {
         return;
       }
 
+      const shouldResolveSchema = _.has(param, 'schema') &&
+        (_.has(param.schema, '$ref') || _.has(param.schema, 'anyOf') ||
+          _.has(param.schema, 'oneOf') || _.has(param.schema, 'allOf'));
+
+      if (shouldResolveSchema) {
+        param.schema = resolveSchema(context, param.schema);
+      }
+
       if (!keepImplicitHeaders && _.includes(IMPLICIT_HEADERS, _.toLower(_.get(param, 'name')))) {
         return;
       }
@@ -2340,14 +2435,25 @@ let QUERYPARAM = 'query',
 
       headers.push(...serialisedHeader);
 
-      if (headerData && headerData.name && headerData.schema && headerData.schema.type) {
-        const { schema } = headerData;
+      if (headerData && headerData.name && headerData.schema) {
+        let { schema } = headerData;
+        const shouldResolveSchema = _.has(schema, '$ref') || _.has(schema, 'anyOf') ||
+          _.has(schema, 'oneOf') || _.has(schema, 'allOf');
+
+        if (shouldResolveSchema) {
+          schema = resolveSchema(context, schema);
+        }
+
+        if (!schema.type) {
+          return;
+        }
+
         properties = {
           type: schema.type,
           format: schema.format,
           default: schema.default,
-          required: schema.required || false,
-          deprecated: schema.deprecated || false,
+          required: schema.required,
+          deprecated: schema.deprecated,
           enum: schema.enum || undefined,
           minLength: schema.minLength,
           maxLength: schema.maxLength,

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "openapi-to-postmanv2",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "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

@@ -281,8 +281,10 @@
 				"in": "query",
 				"description": "component level query param",
 				"required": false,
+				"deprecated": false,
 				"schema": {
-					"type": "string"
+          			"type": "string",
+					"enum": ["medium"]
 				}
 			}
         },