@scalar/postman-to-openapi 0.5.2 → 0.5.3

package/dist/helpers/request-body.js

@@ -1,102 +1,112 @@
-import { processFormDataSchema } from "./form-data.js";
-import { createParameterObject } from "./parameters.js";
-function extractRequestBody(body) {
-  const requestBody = {
-    content: {}
-  };
-  if (body.mode === "raw") {
-    handleRawBody(body, requestBody);
-    return requestBody;
-  }
-  if (body.mode === "formdata" && body.formdata) {
-    handleFormDataBody(body.formdata, requestBody);
-    return requestBody;
-  }
-  if (body.mode === "urlencoded" && body.urlencoded) {
-    handleUrlEncodedBody(body.urlencoded, requestBody);
+import { processFormDataSchema } from './form-data.js';
+import { createParameterObject } from './parameters.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.
+ */
+export function extractRequestBody(body) {
+    const requestBody = {
+        content: {},
+    };
+    if (body.mode === 'raw') {
+        handleRawBody(body, requestBody);
+        return requestBody;
+    }
+    if (body.mode === 'formdata' && body.formdata) {
+        handleFormDataBody(body.formdata, requestBody);
+        return requestBody;
+    }
+    if (body.mode === 'urlencoded' && body.urlencoded) {
+        handleUrlEncodedBody(body.urlencoded, requestBody);
+        return requestBody;
+    }
     return requestBody;
-  }
-  return requestBody;
 }
 function handleRawBody(body, requestBody) {
-  const rawBody = body.raw || "";
-  const isJsonLanguage = body.options?.raw?.language === "json";
-  const hasVariables = /\{\{[\w-]+\}\}/.test(rawBody);
-  let jsonBody;
-  let isJsonBody = false;
-  try {
-    jsonBody = JSON.parse(rawBody);
-    isJsonBody = true;
-  } catch {
-  }
-  if (isJsonBody) {
-    requestBody.content = {
-      "application/json": {
-        schema: {
-          type: "object",
-          example: jsonBody
-        }
-      }
-    };
-    return;
-  }
-  if (hasVariables && isJsonLanguage) {
+    const rawBody = body.raw || '';
+    const isJsonLanguage = body.options?.raw?.language === 'json';
+    // Check if body contains Postman variables (like {{bodyData}})
+    const hasVariables = /\{\{[\w-]+\}\}/.test(rawBody);
+    // Try parsing the raw body as JSON
+    // We use a boolean flag because `null` is a valid JSON value
+    let jsonBody;
+    let isJsonBody = false;
+    try {
+        jsonBody = JSON.parse(rawBody);
+        isJsonBody = true;
+    }
+    catch {
+        // Parsing failed - will handle below
+    }
+    // If we have valid JSON, use it
+    if (isJsonBody) {
+        requestBody.content = {
+            'application/json': {
+                schema: {
+                    type: 'object',
+                    example: jsonBody,
+                },
+            },
+        };
+        return;
+    }
+    // If we have variables and JSON language but could not parse JSON,
+    // create a JSON schema placeholder
+    if (hasVariables && isJsonLanguage) {
+        requestBody.content = {
+            'application/json': {
+                schema: {
+                    type: 'object',
+                    description: 'Body data set via pre-request script',
+                },
+            },
+        };
+        return;
+    }
+    // Fallback to text/plain
     requestBody.content = {
-      "application/json": {
-        schema: {
-          type: "object",
-          description: "Body data set via pre-request script"
-        }
-      }
+        'text/plain': {
+            schema: {
+                type: 'string',
+                examples: rawBody ? [rawBody] : undefined,
+            },
+        },
     };
-    return;
-  }
-  requestBody.content = {
-    "text/plain": {
-      schema: {
-        type: "string",
-        examples: rawBody ? [rawBody] : void 0
-      }
-    }
-  };
 }
 function handleFormDataBody(formdata, requestBody) {
-  requestBody.content = {
-    "multipart/form-data": {
-      schema: processFormDataSchema(formdata)
-    }
-  };
+    requestBody.content = {
+        'multipart/form-data': {
+            schema: processFormDataSchema(formdata),
+        },
+    };
 }
 function handleUrlEncodedBody(urlencoded, requestBody) {
-  const schema = {
-    type: "object",
-    properties: {},
-    required: []
-  };
-  urlencoded.forEach((item) => {
-    if (schema.properties) {
-      const paramObject = createParameterObject(item, "query");
-      const property = {
-        type: "string",
-        examples: [item.value],
-        description: paramObject.description
-      };
-      if (item.disabled === true) {
-        property["x-scalar-disabled"] = true;
-      }
-      schema.properties[item.key] = property;
-      if (paramObject.required) {
-        schema.required?.push(item.key);
-      }
-    }
-  });
-  requestBody.content = {
-    "application/x-www-form-urlencoded": {
-      schema
-    }
-  };
+    const schema = {
+        type: 'object',
+        properties: {},
+        required: [],
+    };
+    urlencoded.forEach((item) => {
+        if (schema.properties) {
+            const paramObject = createParameterObject(item, 'query');
+            const property = {
+                type: 'string',
+                examples: [item.value],
+                description: paramObject.description,
+            };
+            // Add x-scalar-disabled extension if parameter is disabled
+            if (item.disabled === true) {
+                property['x-scalar-disabled'] = true;
+            }
+            schema.properties[item.key] = property;
+            if (paramObject.required) {
+                schema.required?.push(item.key);
+            }
+        }
+    });
+    requestBody.content = {
+        'application/x-www-form-urlencoded': {
+            schema,
+        },
+    };
 }
-export {
-  extractRequestBody
-};
-//# sourceMappingURL=request-body.js.map

package/dist/helpers/responses.js

@@ -1,64 +1,69 @@
-import { inferSchemaFromExample } from "./schemas.js";
-import { extractStatusCodesFromTests } from "./status-codes.js";
-function extractResponses(responses, item) {
-  const statusCodes = item ? extractStatusCodesFromTests(item) : [];
-  const responseMap = responses.reduce((acc, response) => {
-    const statusCode = response.code?.toString() || "default";
-    acc[statusCode] = {
-      description: response.status || "Successful response",
-      headers: extractHeaders(response.header),
-      content: {
-        "application/json": {
-          schema: inferSchemaFromExample(response.body || ""),
-          examples: {
-            default: tryParseJson(response.body || "")
-          }
+import { inferSchemaFromExample } from './schemas.js';
+import { extractStatusCodesFromTests } from './status-codes.js';
+/**
+ * Extracts and converts Postman response objects to OpenAPI response objects.
+ * Processes response status codes, descriptions, headers, and body content,
+ * inferring schemas from example responses when possible.
+ */
+export function extractResponses(responses, item) {
+    // Extract status codes from tests
+    const statusCodes = item ? extractStatusCodesFromTests(item) : [];
+    // Create a map of status codes to descriptions from responses
+    const responseMap = responses.reduce((acc, response) => {
+        const statusCode = response.code?.toString() || 'default';
+        acc[statusCode] = {
+            description: response.status || 'Successful response',
+            headers: extractHeaders(response.header),
+            content: {
+                'application/json': {
+                    schema: inferSchemaFromExample(response.body || ''),
+                    examples: {
+                        default: tryParseJson(response.body || ''),
+                    },
+                },
+            },
+        };
+        return acc;
+    }, {});
+    // Add status codes from tests if not already present
+    statusCodes.forEach((code) => {
+        const codeStr = code.toString();
+        if (!responseMap[codeStr]) {
+            responseMap[codeStr] = {
+                description: 'Successful response',
+                content: {
+                    'application/json': {},
+                },
+            };
         }
-      }
-    };
-    return acc;
-  }, {});
-  statusCodes.forEach((code) => {
-    const codeStr = code.toString();
-    if (!responseMap[codeStr]) {
-      responseMap[codeStr] = {
-        description: "Successful response",
-        content: {
-          "application/json": {}
-        }
-      };
+    });
+    if (Object.keys(responseMap).length === 0) {
+        return undefined;
     }
-  });
-  if (Object.keys(responseMap).length === 0) {
-    return void 0;
-  }
-  return responseMap;
+    return responseMap;
 }
 function extractHeaders(headers) {
-  if (!headers || typeof headers === "string") {
-    return void 0;
-  }
-  const openapiHeaders = {};
-  if (Array.isArray(headers)) {
-    headers.forEach((header) => {
-      openapiHeaders[header.key] = {
-        schema: {
-          type: "string",
-          examples: [header.value]
-        }
-      };
-    });
-  }
-  return openapiHeaders;
+    if (!headers || typeof headers === 'string') {
+        return undefined;
+    }
+    const openapiHeaders = {};
+    if (Array.isArray(headers)) {
+        headers.forEach((header) => {
+            openapiHeaders[header.key] = {
+                schema: {
+                    type: 'string',
+                    examples: [header.value],
+                },
+            };
+        });
+    }
+    return openapiHeaders;
 }
 function tryParseJson(jsonString) {
-  try {
-    return JSON.parse(jsonString);
-  } catch (_e) {
-    return { rawContent: jsonString };
-  }
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (_e) {
+        return { rawContent: jsonString };
+    }
 }
-export {
-  extractResponses
-};
-//# sourceMappingURL=responses.js.map

package/dist/helpers/schemas.js

@@ -1,44 +1,50 @@
-function inferSchemaFromExample(example) {
-  if (Array.isArray(example)) {
-    return {
-      type: "array",
-      items: example.length > 0 ? inferSchemaFromExample(example[0]) : {}
-    };
-  }
-  if (typeof example === "object" && example !== null) {
-    const properties = {};
-    for (const [key, value] of Object.entries(example)) {
-      properties[key] = inferSchemaFromExample(value);
+/**
+ * Infers the schema of an OpenAPI object based on an example value.
+ * This function recursively analyzes the structure of the example value
+ * and returns a corresponding OpenAPI schema object.
+ */
+export function inferSchemaFromExample(example) {
+    if (Array.isArray(example)) {
+        return {
+            type: 'array',
+            items: example.length > 0 ? inferSchemaFromExample(example[0]) : {},
+        };
+    }
+    if (typeof example === 'object' && example !== null) {
+        const properties = {};
+        for (const [key, value] of Object.entries(example)) {
+            properties[key] = inferSchemaFromExample(value);
+        }
+        return {
+            type: 'object',
+            properties,
+        };
     }
     return {
-      type: "object",
-      properties
+        type: typeof example,
     };
-  }
-  return {
-    type: typeof example
-  };
 }
-function inferSchemaType(value) {
-  if (typeof value === "number") {
-    return { type: Number.isInteger(value) ? "integer" : "number" };
-  }
-  if (typeof value === "boolean") {
-    return { type: "boolean" };
-  }
-  if (typeof value === "string") {
-    const num = Number(value);
-    if (!isNaN(num)) {
-      return { type: Number.isInteger(num) ? "integer" : "number" };
+/**
+ * Infers the schema type of a value based on its type.
+ * This function determines the OpenAPI schema type of a value
+ * by checking its JavaScript type and attempting to parse it
+ * as a number or boolean if it's a string.
+ */
+export function inferSchemaType(value) {
+    if (typeof value === 'number') {
+        return { type: Number.isInteger(value) ? 'integer' : 'number' };
+    }
+    if (typeof value === 'boolean') {
+        return { type: 'boolean' };
     }
-    if (value.toLowerCase() === "true" || value.toLowerCase() === "false") {
-      return { type: "boolean" };
+    if (typeof value === 'string') {
+        const num = Number(value);
+        if (!isNaN(num)) {
+            return { type: Number.isInteger(num) ? 'integer' : 'number' };
+        }
+        if (value.toLowerCase() === 'true' || value.toLowerCase() === 'false') {
+            return { type: 'boolean' };
+        }
     }
-  }
-  return { type: "string" };
+    return { type: 'string' };
 }
-export {
-  inferSchemaFromExample,
-  inferSchemaType
-};
-//# sourceMappingURL=schemas.js.map

package/dist/helpers/servers.js

@@ -1,64 +1,90 @@
+/**
+ * Creates a unique key for a path/method combination.
+ * Used to properly deduplicate operations in a Set since JavaScript Sets
+ * compare objects by reference, not by value.
+ */
 function createOperationKey(path, method) {
-  return `${path}::${method}`;
+    return `${path}::${method}`;
 }
+/**
+ * Parses an operation key back into its path and method components.
+ */
 function parseOperationKey(key) {
-  const separatorIndex = key.lastIndexOf("::");
-  return {
-    path: key.substring(0, separatorIndex),
-    method: key.substring(separatorIndex + 2)
-  };
+    const separatorIndex = key.lastIndexOf('::');
+    return {
+        path: key.substring(0, separatorIndex),
+        method: key.substring(separatorIndex + 2),
+    };
 }
-function analyzeServerDistribution(serverUsage, allUniquePaths) {
-  const placement = {
-    document: [],
-    pathItems: /* @__PURE__ */ new Map(),
-    operations: /* @__PURE__ */ new Map()
-  };
-  if (serverUsage.length === 0) {
-    return placement;
-  }
-  const serverMap = /* @__PURE__ */ new Map();
-  for (const usage of serverUsage) {
-    if (!serverMap.has(usage.serverUrl)) {
-      serverMap.set(usage.serverUrl, /* @__PURE__ */ new Set());
+/**
+ * Analyzes server usage and determines the optimal placement level for each server.
+ * Placement logic:
+ * - If server used in all paths → document level
+ * - If server used in multiple paths → document level
+ * - If server used in multiple operations within 1 path → path item level
+ * - If server used in only 1 operation → operation level
+ */
+export function analyzeServerDistribution(serverUsage, allUniquePaths) {
+    const placement = {
+        document: [],
+        pathItems: new Map(),
+        operations: new Map(),
+    };
+    if (serverUsage.length === 0) {
+        return placement;
+    }
+    // Build a map: serverUrl -> Set<operationKey>
+    // Using string keys instead of objects because JavaScript Sets compare by reference
+    const serverMap = new Map();
+    for (const usage of serverUsage) {
+        if (!serverMap.has(usage.serverUrl)) {
+            serverMap.set(usage.serverUrl, new Set());
+        }
+        serverMap.get(usage.serverUrl).add(createOperationKey(usage.path, usage.method));
     }
-    serverMap.get(usage.serverUrl).add(createOperationKey(usage.path, usage.method));
-  }
-  for (const [serverUrl, operationKeys] of serverMap.entries()) {
-    const serverObject = { url: serverUrl };
-    const operations = Array.from(operationKeys).map(parseOperationKey);
-    const uniquePaths = new Set(operations.map((op) => op.path));
-    const pathCount = uniquePaths.size;
-    const coversAllPaths = allUniquePaths.size > 0 && uniquePaths.size === allUniquePaths.size && Array.from(uniquePaths).every((path) => allUniquePaths.has(path));
-    if (coversAllPaths || pathCount > 1) {
-      placement.document.push(serverObject);
-    } else if (operations.length > 1) {
-      const path = operations[0]?.path;
-      if (!path) {
-        continue;
-      }
-      if (!placement.pathItems.has(path)) {
-        placement.pathItems.set(path, []);
-      }
-      placement.pathItems.get(path).push(serverObject);
-    } else {
-      const operation = operations[0];
-      if (!operation) {
-        continue;
-      }
-      if (!placement.operations.has(operation.path)) {
-        placement.operations.set(operation.path, /* @__PURE__ */ new Map());
-      }
-      const methodsMap = placement.operations.get(operation.path);
-      if (!methodsMap.has(operation.method)) {
-        methodsMap.set(operation.method, []);
-      }
-      methodsMap.get(operation.method).push(serverObject);
+    // For each server, determine its placement
+    for (const [serverUrl, operationKeys] of serverMap.entries()) {
+        const serverObject = { url: serverUrl };
+        // Parse operation keys back to path/method pairs
+        const operations = Array.from(operationKeys).map(parseOperationKey);
+        // Count unique paths this server appears in
+        const uniquePaths = new Set(operations.map((op) => op.path));
+        const pathCount = uniquePaths.size;
+        // Check if server covers all paths in the document
+        const coversAllPaths = allUniquePaths.size > 0 &&
+            uniquePaths.size === allUniquePaths.size &&
+            Array.from(uniquePaths).every((path) => allUniquePaths.has(path));
+        if (coversAllPaths || pathCount > 1) {
+            // Server used in all paths or multiple paths → document level
+            placement.document.push(serverObject);
+        }
+        else if (operations.length > 1) {
+            // Server used in multiple operations within 1 path → path item level
+            const path = operations[0]?.path;
+            if (!path) {
+                continue;
+            }
+            if (!placement.pathItems.has(path)) {
+                placement.pathItems.set(path, []);
+            }
+            placement.pathItems.get(path).push(serverObject);
+        }
+        else {
+            // Server used in only 1 operation → operation level
+            const operation = operations[0];
+            if (!operation) {
+                continue;
+            }
+            // Use nested Map structure: path -> method -> servers
+            if (!placement.operations.has(operation.path)) {
+                placement.operations.set(operation.path, new Map());
+            }
+            const methodsMap = placement.operations.get(operation.path);
+            if (!methodsMap.has(operation.method)) {
+                methodsMap.set(operation.method, []);
+            }
+            methodsMap.get(operation.method).push(serverObject);
+        }
     }
-  }
-  return placement;
+    return placement;
 }
-export {
-  analyzeServerDistribution
-};
-//# sourceMappingURL=servers.js.map

package/dist/helpers/status-codes.js

@@ -1,35 +1,45 @@
-function extractStatusCodesFromTests(item) {
-  const statusCodes = [];
-  if (item.event?.length) {
-    item.event.forEach((event) => {
-      if (event.listen === "test" && event.script?.exec) {
-        const scriptLines = Array.isArray(event.script.exec) ? event.script.exec : [event.script.exec];
-        scriptLines.forEach((line) => {
-          const statusCode = parseStatusCodeFromLine(line);
-          if (statusCode) {
-            statusCodes.push(statusCode);
-          }
+/**
+ * Extracts expected status codes from the test scripts of a Postman item.
+ * Looks for patterns like:
+ * - pm.response.to.have.status(201)
+ * - pm.expect(pm.response.code).to.eql(202)
+ * - pm.expect(pm.response.status).to.equal(201)
+ */
+export function extractStatusCodesFromTests(item) {
+    const statusCodes = [];
+    if (item.event?.length) {
+        item.event.forEach((event) => {
+            if (event.listen === 'test' && event.script?.exec) {
+                const scriptLines = Array.isArray(event.script.exec) ? event.script.exec : [event.script.exec];
+                scriptLines.forEach((line) => {
+                    const statusCode = parseStatusCodeFromLine(line);
+                    if (statusCode) {
+                        statusCodes.push(statusCode);
+                    }
+                });
+            }
         });
-      }
-    });
-  }
-  return statusCodes;
+    }
+    return statusCodes;
 }
+/**
+ * Parses a line of script to extract a status code.
+ * Supports patterns like:
+ * - pm.response.to.have.status(201)
+ * - pm.expect(pm.response.code).to.eql(202)
+ * - pm.expect(pm.response.status).to.equal(201)
+ */
 function parseStatusCodeFromLine(line) {
-  const patterns = [
-    /pm\.response\.to\.have\.status\((\d{3})\)/,
-    /pm\.expect\(pm\.response\.code\)\.to\.(?:eql|equal)\((\d{3})\)/,
-    /pm\.expect\(pm\.response\.status\)\.to\.(?:eql|equal)\(['"](\d{3})['"]\)/
-  ];
-  for (const pattern of patterns) {
-    const match = pattern.exec(line)?.at(1);
-    if (match) {
-      return Number.parseInt(match, 10);
+    const patterns = [
+        /pm\.response\.to\.have\.status\((\d{3})\)/,
+        /pm\.expect\(pm\.response\.code\)\.to\.(?:eql|equal)\((\d{3})\)/,
+        /pm\.expect\(pm\.response\.status\)\.to\.(?:eql|equal)\(['"](\d{3})['"]\)/,
+    ];
+    for (const pattern of patterns) {
+        const match = pattern.exec(line)?.at(1);
+        if (match) {
+            return Number.parseInt(match, 10);
+        }
     }
-  }
-  return null;
+    return null;
 }
-export {
-  extractStatusCodesFromTests
-};
-//# sourceMappingURL=status-codes.js.map