@scalar/postman-to-openapi 0.6.2 → 0.7.0

package/dist/helpers/header-utils.js

@@ -0,0 +1,42 @@
+/**
+ * Looks up a header value case-insensitively. Returns the value of the first
+ * non-disabled match, or undefined. Silently ignores string-typed headers
+ * (Postman occasionally stores them that way).
+ */
+export function readHeader(headers, name) {
+    if (!headers || typeof headers === 'string' || !Array.isArray(headers)) {
+        return undefined;
+    }
+    const target = name.toLowerCase();
+    const match = headers.find((h) => h.key?.toLowerCase() === target && !h.disabled);
+    return match?.value;
+}
+/**
+ * Normalises a raw Content-Type header value (`application/json; charset=utf-8`)
+ * to just the media type (`application/json`). Returns undefined for empty input.
+ */
+export function parseMediaType(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.split(';')[0]?.trim().toLowerCase();
+    return trimmed || undefined;
+}
+/**
+ * Picks a single media type from an Accept header value, preferring
+ * `application/json` if present, else the first non-wildcard type. Returns
+ * undefined for `*​/*` alone, empty input, or only wildcard types.
+ */
+export function pickAcceptMediaType(value) {
+    if (!value) {
+        return undefined;
+    }
+    const types = value
+        .split(',')
+        .map((t) => parseMediaType(t))
+        .filter((t) => !!t && t !== '*/*');
+    if (types.length === 0) {
+        return undefined;
+    }
+    return types.find((t) => t === 'application/json') ?? types[0];
+}

package/dist/helpers/merge-operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge-operation.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,eAAe,GAC1B,YAAY,WAAW,CAAC,eAAe,EACvC,YAAY,WAAW,CAAC,eAAe,KACtC,WAAW,CAAC,eAiFd,CAAA"}
+{"version":3,"file":"merge-operation.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAmBxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,eAAe,GAC1B,YAAY,WAAW,CAAC,eAAe,EACvC,YAAY,WAAW,CAAC,eAAe,KACtC,WAAW,CAAC,eA0Gd,CAAA"}

package/dist/helpers/merge-operation.js

@@ -1,3 +1,14 @@
+import { POSTMAN_EXAMPLE_NAME_EXTENSION, POSTMAN_POST_RESPONSE_SCRIPTS_EXTENSION, POSTMAN_PRE_REQUEST_SCRIPTS_EXTENSION, } from './path-items.js';
+const SCRIPT_MERGE_CONFIG = [
+    {
+        extensionKey: POSTMAN_PRE_REQUEST_SCRIPTS_EXTENSION,
+        outputKey: 'x-pre-request',
+    },
+    {
+        extensionKey: POSTMAN_POST_RESPONSE_SCRIPTS_EXTENSION,
+        outputKey: 'x-post-response',
+    },
+];
 /**
  * Merges two OpenAPI OperationObject instances.
  * Assumes that all example names (keys in the 'examples' objects) are unique across both operations.
@@ -102,12 +113,20 @@ export const mergeOperations = (operation1, operation2) => {
             const mediaTypeObj = mediaType;
             if (contentMediaTypeMap.has(contentType)) {
                 const existingMediaType = contentMediaTypeMap.get(contentType);
-                if (existingMediaType && (existingMediaType.examples || mediaTypeObj.examples)) {
+                if (existingMediaType) {
+                    if (mediaTypeObj.schema) {
+                        existingMediaType.schema = mediaTypeObj.schema;
+                    }
+                    if (mediaTypeObj.example !== undefined && existingMediaType.example === undefined) {
+                        existingMediaType.example = mediaTypeObj.example;
+                    }
                     // Assumption: example names (keys) are unique, so this merge is safe
-                    existingMediaType.examples = {
-                        ...existingMediaType.examples,
-                        ...mediaTypeObj.examples,
-                    };
+                    if (existingMediaType.examples || mediaTypeObj.examples) {
+                        existingMediaType.examples = {
+                            ...existingMediaType.examples,
+                            ...mediaTypeObj.examples,
+                        };
+                    }
                 }
             }
             else {
@@ -121,5 +140,101 @@ export const mergeOperations = (operation1, operation2) => {
             content: Object.fromEntries(contentMediaTypeMap),
         };
     }
+    operation.responses = {
+        ...(operation1.responses ?? {}),
+        ...(operation.responses ?? {}),
+    };
+    operation.summary = mergeSummary(operation1.summary, operation.summary);
+    operation.description = mergeDescription(operation1.description, operation.description);
+    for (const config of SCRIPT_MERGE_CONFIG) {
+        const mergedScripts = mergeScriptsBySource(operation1, operation, config.extensionKey, config.outputKey);
+        if (mergedScripts) {
+            operation[config.extensionKey] = mergedScripts;
+        }
+        else {
+            delete operation[config.extensionKey];
+        }
+        updateRenderedScript(operation, config.extensionKey, config.outputKey);
+    }
     return operation;
 };
+const mergeSummary = (firstSummary, secondSummary) => {
+    const first = firstSummary?.trim();
+    const second = secondSummary?.trim();
+    if (!first && !second) {
+        return undefined;
+    }
+    if (!first) {
+        return second;
+    }
+    if (!second) {
+        return first;
+    }
+    if (first.length < second.length) {
+        return first;
+    }
+    return second;
+};
+const mergeDescription = (firstDescription, secondDescription) => {
+    const values = [firstDescription?.trim(), secondDescription?.trim()].filter((candidate) => Boolean(candidate && candidate.length > 0));
+    if (values.length === 0) {
+        return undefined;
+    }
+    const unique = Array.from(new Set(values));
+    return unique.join('\n\n');
+};
+const mergeScriptsBySource = (operation1, operation2, extensionKey, outputKey) => {
+    const scripts = new Map();
+    const operation1HasScriptMap = addScriptsToMap(scripts, operation1[extensionKey]);
+    if (!operation1HasScriptMap) {
+        addLegacyScriptToMap(scripts, operation1, outputKey);
+    }
+    const operation2HasScriptMap = addScriptsToMap(scripts, operation2[extensionKey]);
+    if (!operation2HasScriptMap) {
+        addLegacyScriptToMap(scripts, operation2, outputKey);
+    }
+    if (scripts.size === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(scripts);
+};
+const addScriptsToMap = (target, source) => {
+    if (!source || typeof source !== 'object' || Array.isArray(source)) {
+        return false;
+    }
+    let hasScripts = false;
+    for (const [name, script] of Object.entries(source)) {
+        if (!name || typeof script !== 'string' || script.length === 0) {
+            continue;
+        }
+        target.set(name, script);
+        hasScripts = true;
+    }
+    return hasScripts;
+};
+const addLegacyScriptToMap = (target, operation, outputKey) => {
+    const legacyScript = operation[outputKey];
+    if (typeof legacyScript !== 'string' || legacyScript.length === 0) {
+        return;
+    }
+    const sourceName = typeof operation[POSTMAN_EXAMPLE_NAME_EXTENSION] === 'string' &&
+        operation[POSTMAN_EXAMPLE_NAME_EXTENSION].length > 0
+        ? operation[POSTMAN_EXAMPLE_NAME_EXTENSION]
+        : 'Default example';
+    target.set(sourceName, legacyScript);
+};
+const updateRenderedScript = (operation, extensionKey, scriptKey) => {
+    const scripts = operation[extensionKey];
+    if (!scripts || typeof scripts !== 'object' || Array.isArray(scripts)) {
+        delete operation[scriptKey];
+        return;
+    }
+    const sections = Object.entries(scripts)
+        .filter((entry) => typeof entry[0] === 'string' && typeof entry[1] === 'string')
+        .map(([sourceName, script]) => `// --- ${sourceName} ---\n${script}`);
+    if (sections.length === 0) {
+        delete operation[scriptKey];
+        return;
+    }
+    operation[scriptKey] = sections.join('\n\n');
+};

package/dist/helpers/merge-path-item.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge-path-item.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-path-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAOxD,eAAO,MAAM,oBAAoB,oBAAoB,CAAA;AAErD,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,MAAM,WAAW,CAAC,cAAc,CAAC,EASvE,CAAA;AAED,eAAO,MAAM,aAAa,GACxB,OAAO,WAAW,CAAC,WAAW,EAC9B,mBAAmB,MAAM,EACzB,UAAU,WAAW,CAAC,cAAc,EACpC,iBAAgB,OAAe,KAC9B,IA8BF,CAAA"}
+{"version":3,"file":"merge-path-item.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-path-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAYxD,eAAO,MAAM,oBAAoB,oBAAoB,CAAA;AAErD,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,MAAM,WAAW,CAAC,cAAc,CAAC,EASvE,CAAA;AAED,eAAO,MAAM,aAAa,GACxB,OAAO,WAAW,CAAC,WAAW,EAC9B,mBAAmB,MAAM,EACzB,UAAU,WAAW,CAAC,cAAc,EACpC,iBAAgB,OAAe,KAC9B,IAuCF,CAAA"}

package/dist/helpers/merge-path-item.js

@@ -1,6 +1,7 @@
 import { generateUniqueValue } from '../helpers/generate-unique-value.js';
 import { getOperationExamples } from '../helpers/get-operation-examples.js';
 import { mergeOperations } from '../helpers/merge-operation.js';
+import { POSTMAN_EXAMPLE_NAME_EXTENSION, POSTMAN_POST_RESPONSE_SCRIPTS_EXTENSION, POSTMAN_PRE_REQUEST_SCRIPTS_EXTENSION, } from '../helpers/path-items.js';
 import { renameOperationExamples } from '../helpers/rename-operation-example.js';
 export const DEFAULT_EXAMPLE_NAME = 'Default example';
 export const OPERATION_KEYS = [
@@ -21,17 +22,40 @@ export const mergePathItem = (paths, normalizedPathKey, pathItem, mergeOperation
         }
         const isOperationKey = OPERATION_KEYS.includes(key);
         if (isOperationKey && targetPath[key] && mergeOperation) {
+            const incomingOperation = pathItem[key];
+            const sourceName = typeof incomingOperation[POSTMAN_EXAMPLE_NAME_EXTENSION] === 'string'
+                ? incomingOperation[POSTMAN_EXAMPLE_NAME_EXTENSION]
+                : DEFAULT_EXAMPLE_NAME;
             // Get all example names from the target path
             const exampleNames = getOperationExamples(targetPath);
             // Generate a unique example name
-            const newExampleName = generateUniqueValue(DEFAULT_EXAMPLE_NAME, (value) => !exampleNames.has(value), '#');
-            // Rename operation examples from the new path item (we know it's gonna have only the default example)
-            renameOperationExamples(pathItem[key], DEFAULT_EXAMPLE_NAME, newExampleName);
+            const newExampleName = generateUniqueValue(sourceName, (value) => !exampleNames.has(value), '#');
+            // Rename operation examples from the new path item if this source name already exists
+            renameOperationExamples(incomingOperation, sourceName, newExampleName);
+            updateExtensionKey(incomingOperation, POSTMAN_PRE_REQUEST_SCRIPTS_EXTENSION, sourceName, newExampleName);
+            updateExtensionKey(incomingOperation, POSTMAN_POST_RESPONSE_SCRIPTS_EXTENSION, sourceName, newExampleName);
+            incomingOperation[POSTMAN_EXAMPLE_NAME_EXTENSION] = newExampleName;
             // Merge the operations
-            targetPath[key] = mergeOperations(targetPath[key], pathItem[key]);
+            targetPath[key] = mergeOperations(targetPath[key], incomingOperation);
             continue;
         }
         targetPath[key] = value;
     }
     paths[normalizedPathKey] = targetPath;
 };
+const updateExtensionKey = (operation, extensionKey, oldKey, newKey) => {
+    if (oldKey === newKey) {
+        return;
+    }
+    const map = operation[extensionKey];
+    if (!map || typeof map !== 'object' || Array.isArray(map)) {
+        return;
+    }
+    const castedMap = map;
+    const value = castedMap[oldKey];
+    if (value === undefined) {
+        return;
+    }
+    delete castedMap[oldKey];
+    castedMap[newKey] = value;
+};

package/dist/helpers/parameters.d.ts

@@ -3,8 +3,11 @@ import type { Request } from '../types.js';
 /**
  * Extracts parameters from a Postman request and converts them to OpenAPI parameter objects.
  * Processes query, path, and header parameters from the request URL and headers.
+ *
+ * Headers on the built-in block-list (content negotiation, transport, auth) are
+ * dropped unless the caller passes them via `keepHeaders` (case-insensitive).
  */
-export declare function extractParameters(request: Request, exampleName: string): OpenAPIV3_1.ParameterObject[];
+export declare function extractParameters(request: Request, exampleName: string, keepHeaders?: readonly string[]): OpenAPIV3_1.ParameterObject[];
 /**
  * Creates an OpenAPI parameter object from a Postman parameter.
  */

package/dist/helpers/parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../src/helpers/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAU,OAAO,EAAE,MAAM,SAAS,CAAA;AAI9C;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,GAAG,WAAW,CAAC,eAAe,EAAE,CA2DtG;AAoBD;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,GAAG,EACV,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,EACpC,WAAW,EAAE,MAAM,GAClB,WAAW,CAAC,eAAe,CAwD7B"}
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../src/helpers/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAU,OAAO,EAAE,MAAM,SAAS,CAAA;AAuC9C;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,GAC9B,WAAW,CAAC,eAAe,EAAE,CA8D/B;AAoBD;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,GAAG,EACV,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,EACpC,WAAW,EAAE,MAAM,GAClB,WAAW,CAAC,eAAe,CAwD7B"}

package/dist/helpers/parameters.js

@@ -1,9 +1,45 @@
 import { inferSchemaType } from './schemas.js';
+/**
+ * Header keys (lower-case) that never become `parameters[in=header]` on an
+ * OpenAPI operation. They either describe the transport (Host, Connection),
+ * overlap with `requestBody.content` / `responses.content` (Accept,
+ * Content-Type), or belong in `components.securitySchemes` (Authorization,
+ * Cookie). Callers can opt a specific name back in via `ConvertOptions.keepHeaders`.
+ */
+const BLOCKED_HEADERS = new Set([
+    // Content negotiation
+    'accept',
+    'accept-encoding',
+    'accept-language',
+    'content-type',
+    // Transport / hop-by-hop
+    'connection',
+    'content-length',
+    'host',
+    'transfer-encoding',
+    // Auth — belong in components.securitySchemes
+    'authorization',
+    'cookie',
+    'proxy-authorization',
+]);
+function isBlockedHeader(name, keepHeaders) {
+    if (!name) {
+        return false;
+    }
+    const lower = name.toLowerCase();
+    if (keepHeaders?.some((kept) => kept.toLowerCase() === lower)) {
+        return false;
+    }
+    return BLOCKED_HEADERS.has(lower);
+}
 /**
  * Extracts parameters from a Postman request and converts them to OpenAPI parameter objects.
  * Processes query, path, and header parameters from the request URL and headers.
+ *
+ * Headers on the built-in block-list (content negotiation, transport, auth) are
+ * dropped unless the caller passes them via `keepHeaders` (case-insensitive).
  */
-export function extractParameters(request, exampleName) {
+export function extractParameters(request, exampleName, keepHeaders) {
     const parameters = [];
     const parameterMap = new Map();
     if (typeof request === 'string' || !request.url) {
@@ -48,6 +84,9 @@ export function extractParameters(request, exampleName) {
     // Process header parameters
     if (request.header && Array.isArray(request.header)) {
         request.header.forEach((header) => {
+            if (isBlockedHeader(header.key, keepHeaders)) {
+                return;
+            }
             const paramObj = createParameterObject(header, 'header', exampleName);
             if (paramObj.name) {
                 parameterMap.set(paramObj.name, paramObj);

package/dist/helpers/path-items.d.ts

@@ -1,24 +1,34 @@
 import type { OpenAPIV3_1 } from '@scalar/openapi-types';
 import type { Item, ItemGroup } from '../types.js';
 type HttpMethods = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace';
+export declare const POSTMAN_EXAMPLE_NAME_EXTENSION = "x-postman-example-name";
+export declare const POSTMAN_PRE_REQUEST_SCRIPTS_EXTENSION = "x-postman-pre-request-scripts";
+export declare const POSTMAN_POST_RESPONSE_SCRIPTS_EXTENSION = "x-postman-post-response-scripts";
+export declare const POSTMAN_FOLDER_SEGMENTS_EXTENSION = "x-postman-folder-segments";
 /**
  * Information about server usage for an operation.
  */
 export type ServerUsage = {
     serverUrl: string;
+    server?: OpenAPIV3_1.ServerObject;
     path: string;
     method: HttpMethods;
 };
+type CollectionVariableLookup = ReadonlyMap<string, string>;
 /**
  * Processes a Postman collection item or item group and returns
  * the corresponding OpenAPI paths and components.
  * Handles nested item groups, extracts request details, and generates corresponding
  * OpenAPI path items and operations.
  */
-export declare function processItem(item: Item | ItemGroup, exampleName?: string, parentTags?: string[], parentPath?: string): {
+export declare function processItem(item: Item | ItemGroup, exampleName?: string, parentTags?: string[], parentPath?: string, preserveCollapsedVariants?: boolean, resolveTagName?: (segments: string[]) => string | undefined, collectionVariableLookup?: CollectionVariableLookup, keepHeaders?: readonly string[]): {
     paths: OpenAPIV3_1.PathsObject;
     components: OpenAPIV3_1.ComponentsObject;
     serverUsage: ServerUsage[];
 };
+export declare function parseStatusCodeFromRequestName(requestName: string | undefined): {
+    statusCode: string;
+    description: string;
+} | null;
 export {};
 //# sourceMappingURL=path-items.d.ts.map

package/dist/helpers/path-items.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-items.d.ts","sourceRoot":"","sources":["../../src/helpers/path-items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAW9C,KAAK,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE7F;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,WAAW,CAAA;CACpB,CAAA;AAoBD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,WAAW,GAAE,MAAkB,EAC/B,UAAU,GAAE,MAAM,EAAO,EACzB,UAAU,GAAE,MAAW,GACtB;IACD,KAAK,EAAE,WAAW,CAAC,WAAW,CAAA;IAC9B,UAAU,EAAE,WAAW,CAAC,gBAAgB,CAAA;IACxC,WAAW,EAAE,WAAW,EAAE,CAAA;CAC3B,CA2KA"}
+{"version":3,"file":"path-items.d.ts","sourceRoot":"","sources":["../../src/helpers/path-items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAY9C,KAAK,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE7F,eAAO,MAAM,8BAA8B,2BAA2B,CAAA;AACtE,eAAO,MAAM,qCAAqC,kCAAkC,CAAA;AACpF,eAAO,MAAM,uCAAuC,oCAAoC,CAAA;AAIxF,eAAO,MAAM,iCAAiC,8BAA8B,CAAA;AAE5E;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,WAAW,CAAC,YAAY,CAAA;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,WAAW,CAAA;CACpB,CAAA;AAED,KAAK,wBAAwB,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAoB3D;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,WAAW,GAAE,MAAkB,EAC/B,UAAU,GAAE,MAAM,EAAO,EACzB,UAAU,GAAE,MAAW,EACvB,yBAAyB,GAAE,OAAe,EAC1C,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,SAAS,EAC3D,wBAAwB,GAAE,wBAAoC,EAC9D,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,GAC9B;IACD,KAAK,EAAE,WAAW,CAAC,WAAW,CAAA;IAC9B,UAAU,EAAE,WAAW,CAAC,gBAAgB,CAAA;IACxC,WAAW,EAAE,WAAW,EAAE,CAAA;CAC3B,CAoNA;AAED,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAkCpD"}

package/dist/helpers/path-items.js

@@ -1,11 +1,19 @@
 import { processAuth } from './auth.js';
+import { parseMediaType, pickAcceptMediaType, readHeader } from './header-utils.js';
 import { parseMdTable } from './markdown.js';
 import { extractParameters } from './parameters.js';
 import { processPostResponseScripts } from './post-response-scripts.js';
 import { processPreRequestScripts } from './pre-request-scripts.js';
 import { extractRequestBody } from './request-body.js';
-import { extractResponses } from './responses.js';
-import { extractPathFromUrl, extractPathParameterNames, extractServerFromUrl, normalizePath } from './urls.js';
+import { DEFAULT_RESPONSE_DESCRIPTIONS, extractResponses } from './responses.js';
+import { extractPathFromUrl, extractPathParameterNames, extractServerObjectFromUrl, normalizePath } from './urls.js';
+export const POSTMAN_EXAMPLE_NAME_EXTENSION = 'x-postman-example-name';
+export const POSTMAN_PRE_REQUEST_SCRIPTS_EXTENSION = 'x-postman-pre-request-scripts';
+export const POSTMAN_POST_RESPONSE_SCRIPTS_EXTENSION = 'x-postman-post-response-scripts';
+// Raw Postman folder-name chain for the operation. Used internally to preserve
+// template hints (for example `/applications/{id}`) even when tag names are
+// simplified. Stripped before emitting the final OpenAPI document.
+export const POSTMAN_FOLDER_SEGMENTS_EXTENSION = 'x-postman-folder-segments';
 function ensureRequestBodyContent(requestBody) {
     const content = requestBody.content ?? {};
     if (Object.keys(content).length === 0) {
@@ -27,14 +35,14 @@ function ensureRequestBodyContent(requestBody) {
  * Handles nested item groups, extracts request details, and generates corresponding
  * OpenAPI path items and operations.
  */
-export function processItem(item, exampleName = 'default', parentTags = [], parentPath = '') {
+export function processItem(item, exampleName = 'default', parentTags = [], parentPath = '', preserveCollapsedVariants = false, resolveTagName, collectionVariableLookup = new Map(), keepHeaders) {
     const paths = {};
     const components = {};
     const serverUsage = [];
     if ('item' in item && Array.isArray(item.item)) {
         const newParentTags = item.name ? [...parentTags, item.name] : parentTags;
         item.item.forEach((childItem) => {
-            const childResult = processItem(childItem, exampleName, newParentTags, `${parentPath}/${item.name || ''}`);
+            const childResult = processItem(childItem, exampleName, newParentTags, `${parentPath}/${item.name || ''}`, preserveCollapsedVariants, resolveTagName, collectionVariableLookup, keepHeaders);
             // Merge child paths and components
             for (const [pathKey, pathItem] of Object.entries(childResult.paths)) {
                 if (!paths[pathKey]) {
@@ -63,16 +71,19 @@ export function processItem(item, exampleName = 'default', parentTags = [], pare
         return { paths, components, serverUsage };
     }
     const { request, name, response } = item;
+    const sourceRequestName = name?.trim() || exampleName;
+    const operationExampleName = preserveCollapsedVariants ? sourceRequestName : exampleName;
     const method = (typeof request === 'string' ? 'get' : request.method || 'get').toLowerCase();
     const requestUrl = typeof request === 'string' ? request : typeof request.url === 'string' ? request.url : (request.url?.raw ?? '');
     const path = extractPathFromUrl(requestUrl);
     // Normalize path parameters from ':param' to '{param}'
     const normalizedPath = normalizePath(path);
     // Extract server URL from request URL
-    const serverUrl = extractServerFromUrl(requestUrl);
-    if (serverUrl) {
+    const server = extractServerObjectFromUrl(requestUrl, collectionVariableLookup);
+    if (server?.url) {
         serverUsage.push({
-            serverUrl,
+            serverUrl: server.url,
+            server,
             path: normalizedPath,
             method,
         });
@@ -86,22 +97,45 @@ export function processItem(item, exampleName = 'default', parentTags = [], pare
         : typeof request.description === 'string'
             ? request.description
             : (request.description?.content ?? '');
+    const tagName = parentTags.length > 0 ? (resolveTagName ? resolveTagName(parentTags) : parentTags.join(' > ')) : undefined;
+    // Derive media-type signals from request headers before they are filtered out
+    // of `parameters[in=header]`. Content-Type drives the request body media type;
+    // Accept drives responses when no saved-response Content-Type is available.
+    const requestHeaders = typeof request === 'string' ? undefined : request.header;
+    const contentType = parseMediaType(readHeader(requestHeaders, 'Content-Type'));
+    const acceptMediaType = pickAcceptMediaType(readHeader(requestHeaders, 'Accept'));
     const operationObject = {
-        tags: parentTags.length > 0 ? [parentTags.join(' > ')] : undefined,
+        tags: tagName ? [tagName] : undefined,
         summary,
         description,
-        responses: extractResponses(response || [], item),
+        responses: extractResponses(response || [], item, acceptMediaType),
         parameters: [],
     };
+    if (parentTags.length > 0) {
+        operationObject[POSTMAN_FOLDER_SEGMENTS_EXTENSION] = [...parentTags];
+    }
+    if (preserveCollapsedVariants) {
+        operationObject[POSTMAN_EXAMPLE_NAME_EXTENSION] = sourceRequestName;
+    }
     // Add pre-request scripts if present
     const preRequestScript = processPreRequestScripts(item.event);
     if (preRequestScript) {
         operationObject['x-pre-request'] = preRequestScript;
+        if (preserveCollapsedVariants) {
+            operationObject[POSTMAN_PRE_REQUEST_SCRIPTS_EXTENSION] = {
+                [sourceRequestName]: preRequestScript,
+            };
+        }
     }
     // Add post-response scripts if present
     const postResponseScript = processPostResponseScripts(item.event);
     if (postResponseScript) {
         operationObject['x-post-response'] = postResponseScript;
+        if (preserveCollapsedVariants) {
+            operationObject[POSTMAN_POST_RESPONSE_SCRIPTS_EXTENSION] = {
+                [sourceRequestName]: postResponseScript,
+            };
+        }
     }
     // Only add operationId if it was explicitly provided
     if (operationId) {
@@ -109,7 +143,7 @@ export function processItem(item, exampleName = 'default', parentTags = [], pare
     }
     // Extract parameters from the request (query, path, header)
     // This should always happen, regardless of whether a description exists
-    const extractedParameters = extractParameters(request, exampleName);
+    const extractedParameters = extractParameters(request, operationExampleName, keepHeaders);
     // Merge parameters, giving priority to those from the Markdown table if description exists
     const mergedParameters = new Map();
     // Add extracted parameters, filtering out path parameters not in the path
@@ -156,7 +190,7 @@ export function processItem(item, exampleName = 'default', parentTags = [], pare
     }
     // Allow request bodies for all methods (including GET) if body is present
     if (typeof request !== 'string' && request.body) {
-        const requestBody = extractRequestBody(request.body, exampleName);
+        const requestBody = extractRequestBody(request.body, operationExampleName, contentType);
         ensureRequestBodyContent(requestBody);
         // Only add requestBody if it has content
         if (requestBody.content && Object.keys(requestBody.content).length > 0) {
@@ -168,8 +202,40 @@ export function processItem(item, exampleName = 'default', parentTags = [], pare
     }
     const pathItem = paths[path];
     pathItem[method] = operationObject;
+    if (preserveCollapsedVariants) {
+        addResponseFromRequestName(pathItem[method], name);
+    }
     return { paths, components, serverUsage };
 }
+export function parseStatusCodeFromRequestName(requestName) {
+    if (!requestName) {
+        return null;
+    }
+    const trimmedStart = requestName.trimStart();
+    if (trimmedStart.length < 4) {
+        return null;
+    }
+    const statusCode = trimmedStart.slice(0, 3);
+    if (!isThreeDigitStatusCode(statusCode)) {
+        return null;
+    }
+    let separatorIndex = 3;
+    while (trimmedStart[separatorIndex] === ' ') {
+        separatorIndex += 1;
+    }
+    const separator = trimmedStart[separatorIndex];
+    if (separator !== '-' && separator !== ':') {
+        return null;
+    }
+    let descriptionIndex = separatorIndex + 1;
+    while (trimmedStart[descriptionIndex] === ' ') {
+        descriptionIndex += 1;
+    }
+    return {
+        statusCode,
+        description: trimmedStart.slice(descriptionIndex).trim() || 'Response',
+    };
+}
 /** OpenAPI 3.1 parameter schema types (ParameterObject uses OpenAPIV3_1). */
 const OPENAPI_PARAM_SCHEMA_TYPES = ['string', 'number', 'integer', 'boolean', 'object', 'array'];
 function toOpenApiParamSchemaType(s) {
@@ -259,3 +325,37 @@ function extractOperationInfo(name) {
     const summary = name.substring(0, lastBracketIndex).trim();
     return { operationId, summary };
 }
+function addResponseFromRequestName(operationObject, requestName) {
+    const parsedStatus = parseStatusCodeFromRequestName(requestName);
+    if (!parsedStatus) {
+        return;
+    }
+    operationObject.responses = operationObject.responses ?? {};
+    const existingResponse = operationObject.responses[parsedStatus.statusCode];
+    if (!existingResponse) {
+        operationObject.responses[parsedStatus.statusCode] = { description: parsedStatus.description };
+        return;
+    }
+    const defaultDescriptions = new Set([
+        'Successful response',
+        'Response',
+        ...Object.values(DEFAULT_RESPONSE_DESCRIPTIONS),
+    ]);
+    if (typeof existingResponse === 'object' &&
+        !('$ref' in existingResponse) &&
+        defaultDescriptions.has(existingResponse.description ?? '')) {
+        existingResponse.description = parsedStatus.description;
+    }
+}
+function isThreeDigitStatusCode(value) {
+    if (value.length !== 3) {
+        return false;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const charCode = value.charCodeAt(index);
+        if (charCode < 48 || charCode > 57) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/helpers/request-body.d.ts

@@ -3,6 +3,10 @@ import type { RequestBody } from '../types.js';
 /**
  * Extracts and converts the request body from a Postman request to an OpenAPI RequestBodyObject.
  * Handles raw JSON, form-data, and URL-encoded body types, creating appropriate schemas and content types.
+ *
+ * When `contentType` is provided (already normalised via `parseMediaType`), it
+ * wins over the Postman `options.raw.language` hint for `raw` bodies.
+ * `formdata` and `urlencoded` modes keep their natural media types.
  */
-export declare function extractRequestBody(body: RequestBody, exampleName: string): OpenAPIV3_1.RequestBodyObject;
+export declare function extractRequestBody(body: RequestBody, exampleName: string, contentType?: string): OpenAPIV3_1.RequestBodyObject;
 //# sourceMappingURL=request-body.d.ts.map

package/dist/helpers/request-body.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-body.d.ts","sourceRoot":"","sources":["../../src/helpers/request-body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAiB,WAAW,EAAuB,MAAM,SAAS,CAAA;AAK9E;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,GAAG,WAAW,CAAC,iBAAiB,CAqBxG"}
+{"version":3,"file":"request-body.d.ts","sourceRoot":"","sources":["../../src/helpers/request-body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAiB,WAAW,EAAuB,MAAM,SAAS,CAAA;AAK9E;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,MAAM,GACnB,WAAW,CAAC,iBAAiB,CAqB/B"}