@scalar/postman-to-openapi 0.5.2 → 0.5.3

package/dist/helpers/auth.js

@@ -1,113 +1,137 @@
+// Constants for security scheme names and URLs
 const AUTH_SCHEMES = {
-  API_KEY: "apikeyAuth",
-  BASIC: "basicAuth",
-  BEARER: "bearerAuth",
-  OAUTH2: "oauth2Auth"
+    API_KEY: 'apikeyAuth',
+    BASIC: 'basicAuth',
+    BEARER: 'bearerAuth',
+    OAUTH2: 'oauth2Auth',
 };
 const OAUTH2_DEFAULTS = {
-  AUTHORIZE_URL: "/oauth/authorize",
-  TOKEN_URL: "/oauth/token"
+    AUTHORIZE_URL: '/oauth/authorize',
+    TOKEN_URL: '/oauth/token',
 };
+/**
+ * Creates security configuration for API key authentication
+ */
 function createApiKeyConfig() {
-  return {
-    scheme: {
-      type: "apiKey",
-      name: "api_key",
-      in: "header"
-    },
-    requirement: { [AUTH_SCHEMES.API_KEY]: [] }
-  };
+    return {
+        scheme: {
+            type: 'apiKey',
+            name: 'api_key',
+            in: 'header',
+        },
+        requirement: { [AUTH_SCHEMES.API_KEY]: [] },
+    };
 }
+/**
+ * Creates security configuration for Basic authentication
+ */
 function createBasicConfig() {
-  return {
-    scheme: {
-      type: "http",
-      scheme: "basic"
-    },
-    requirement: { [AUTH_SCHEMES.BASIC]: [] }
-  };
+    return {
+        scheme: {
+            type: 'http',
+            scheme: 'basic',
+        },
+        requirement: { [AUTH_SCHEMES.BASIC]: [] },
+    };
 }
+/**
+ * Creates security configuration for Bearer token authentication
+ */
 function createBearerConfig() {
-  return {
-    scheme: {
-      type: "http",
-      scheme: "bearer"
-    },
-    requirement: { [AUTH_SCHEMES.BEARER]: [] }
-  };
-}
-function createOAuth2Config(auth) {
-  if (!auth) {
     return {
-      scheme: {},
-      requirement: {}
+        scheme: {
+            type: 'http',
+            scheme: 'bearer',
+        },
+        requirement: { [AUTH_SCHEMES.BEARER]: [] },
     };
-  }
-  const oauth2Attrs = auth.oauth2 || [];
-  const attrMap = /* @__PURE__ */ new Map();
-  oauth2Attrs.forEach((attr) => {
-    if (attr.key && attr.value !== void 0) {
-      attrMap.set(attr.key, String(attr.value));
+}
+/**
+ * Creates security configuration for OAuth2 authentication
+ * Extracts actual OAuth2 URLs and scopes from the Postman auth object
+ */
+function createOAuth2Config(auth) {
+    if (!auth) {
+        return {
+            scheme: {},
+            requirement: {},
+        };
     }
-  });
-  const authUrl = attrMap.get("authUrl") || attrMap.get("authorizationUrl") || OAUTH2_DEFAULTS.AUTHORIZE_URL;
-  const tokenUrl = attrMap.get("accessTokenUrl") || attrMap.get("tokenUrl") || OAUTH2_DEFAULTS.TOKEN_URL;
-  const scopeValue = attrMap.get("scope") || "";
-  const scopes = {};
-  if (scopeValue) {
-    const scopeList = scopeValue.split(/[,\s]+/).filter(Boolean);
-    scopeList.forEach((scope) => {
-      scopes[scope] = scope;
-    });
-  }
-  return {
-    scheme: {
-      type: "oauth2",
-      flows: {
-        authorizationCode: {
-          authorizationUrl: authUrl,
-          tokenUrl,
-          scopes
+    const oauth2Attrs = auth.oauth2 || [];
+    const attrMap = new Map();
+    oauth2Attrs.forEach((attr) => {
+        if (attr.key && attr.value !== undefined) {
+            attrMap.set(attr.key, String(attr.value));
         }
-      }
-    },
-    requirement: { [AUTH_SCHEMES.OAUTH2]: Object.keys(scopes) }
-  };
+    });
+    const authUrl = attrMap.get('authUrl') || attrMap.get('authorizationUrl') || OAUTH2_DEFAULTS.AUTHORIZE_URL;
+    const tokenUrl = attrMap.get('accessTokenUrl') || attrMap.get('tokenUrl') || OAUTH2_DEFAULTS.TOKEN_URL;
+    const scopeValue = attrMap.get('scope') || '';
+    // Parse scopes from the scope value (can be space or comma separated)
+    const scopes = {};
+    if (scopeValue) {
+        const scopeList = scopeValue.split(/[,\s]+/).filter(Boolean);
+        scopeList.forEach((scope) => {
+            scopes[scope] = scope;
+        });
+    }
+    return {
+        scheme: {
+            type: 'oauth2',
+            flows: {
+                authorizationCode: {
+                    authorizationUrl: authUrl,
+                    tokenUrl,
+                    scopes,
+                },
+            },
+        },
+        requirement: { [AUTH_SCHEMES.OAUTH2]: Object.keys(scopes) },
+    };
 }
+/**
+ * Creates security configuration for no authentication
+ */
 function createNoAuthConfig() {
-  return {
-    scheme: {},
-    requirement: {}
-  };
+    return {
+        scheme: {},
+        requirement: {},
+    };
 }
+/**
+ * Maps authentication types to their configuration creators
+ */
 const AUTH_TYPE_HANDLERS = {
-  apikey: createApiKeyConfig,
-  basic: createBasicConfig,
-  bearer: createBearerConfig,
-  oauth2: createOAuth2Config,
-  noauth: createNoAuthConfig
+    apikey: createApiKeyConfig,
+    basic: createBasicConfig,
+    bearer: createBearerConfig,
+    oauth2: createOAuth2Config,
+    noauth: createNoAuthConfig,
 };
-function processAuth(auth) {
-  const securitySchemes = {};
-  const security = [];
-  try {
-    const handler = AUTH_TYPE_HANDLERS[auth.type];
-    if (!handler) {
-      throw new Error(`Unsupported authentication type: ${auth.type}`);
+/**
+ * Processes authentication information from a Postman collection and updates
+ * the OpenAPI document with the corresponding security schemes and requirements.
+ * Supports API key, basic auth, bearer token, OAuth2, and no authentication types.
+ */
+export function processAuth(auth) {
+    const securitySchemes = {};
+    const security = [];
+    try {
+        const handler = AUTH_TYPE_HANDLERS[auth.type];
+        if (!handler) {
+            throw new Error(`Unsupported authentication type: ${auth.type}`);
+        }
+        const { scheme, requirement } = handler(auth);
+        // Only add security schemes and requirements if they're not empty
+        if (Object.keys(scheme).length > 0) {
+            const schemeKey = `${auth.type}Auth`;
+            securitySchemes[schemeKey] = scheme;
+            security.push(requirement);
+        }
     }
-    const { scheme, requirement } = handler(auth);
-    if (Object.keys(scheme).length > 0) {
-      const schemeKey = `${auth.type}Auth`;
-      securitySchemes[schemeKey] = scheme;
-      security.push(requirement);
+    catch (error) {
+        console.error('Error processing authentication:', error);
+        throw error;
     }
-  } catch (error) {
-    console.error("Error processing authentication:", error);
-    throw error;
-  }
-  return { securitySchemes, security };
+    return { securitySchemes, security };
 }
-export {
-  processAuth
-};
-//# sourceMappingURL=auth.js.map

package/dist/helpers/contact.js

@@ -1,25 +1,29 @@
+// Constants for contact variable keys
 const VARIABLE_KEYS = {
-  NAME: "contact.name",
-  URL: "contact.url",
-  EMAIL: "contact.email"
+    NAME: 'contact.name',
+    URL: 'contact.url',
+    EMAIL: 'contact.email',
 };
+/**
+ * Finds a specific variable in the collection by its key
+ */
 function findVariable(collection, key) {
-  return collection.variable?.find((v) => v.key === key);
+    return collection.variable?.find((v) => v.key === key);
 }
-function processContact(collection) {
-  const nameVar = findVariable(collection, VARIABLE_KEYS.NAME);
-  const urlVar = findVariable(collection, VARIABLE_KEYS.URL);
-  const emailVar = findVariable(collection, VARIABLE_KEYS.EMAIL);
-  if (!nameVar?.value && !urlVar?.value && !emailVar?.value) {
-    return void 0;
-  }
-  return {
-    ...nameVar?.value && typeof nameVar.value === "string" && { name: nameVar.value },
-    ...urlVar?.value && typeof urlVar.value === "string" && { url: urlVar.value },
-    ...emailVar?.value && typeof emailVar.value === "string" && { email: emailVar.value }
-  };
+/**
+ * Processes contact information from collection variables.
+ * Returns an OpenAPI Contact Object if at least one contact field is present.
+ */
+export function processContact(collection) {
+    const nameVar = findVariable(collection, VARIABLE_KEYS.NAME);
+    const urlVar = findVariable(collection, VARIABLE_KEYS.URL);
+    const emailVar = findVariable(collection, VARIABLE_KEYS.EMAIL);
+    if (!nameVar?.value && !urlVar?.value && !emailVar?.value) {
+        return undefined;
+    }
+    return {
+        ...(nameVar?.value && typeof nameVar.value === 'string' && { name: nameVar.value }),
+        ...(urlVar?.value && typeof urlVar.value === 'string' && { url: urlVar.value }),
+        ...(emailVar?.value && typeof emailVar.value === 'string' && { email: emailVar.value }),
+    };
 }
-export {
-  processContact
-};
-//# sourceMappingURL=contact.js.map

package/dist/helpers/external-docs.js

@@ -1,32 +1,40 @@
+// Constants for variable keys
 const VARIABLE_KEYS = {
-  URL: "externalDocs.url",
-  DESCRIPTION: "externalDocs.description"
+    URL: 'externalDocs.url',
+    DESCRIPTION: 'externalDocs.description',
 };
+/**
+ * Finds a specific variable in the collection by its key
+ */
 function findVariable(collection, key) {
-  return collection.variable?.find((v) => v.key === key);
+    return collection.variable?.find((v) => v.key === key);
 }
-function processExternalDocs(collection) {
-  try {
-    const urlVariable = findVariable(collection, VARIABLE_KEYS.URL);
-    const descriptionVariable = findVariable(collection, VARIABLE_KEYS.DESCRIPTION);
-    if (!urlVariable?.value) {
-      return void 0;
+/**
+ * Processes the external documentation information from a Postman Collection.
+ * This function checks for 'externalDocs.url' and 'externalDocs.description'
+ * in the collection variables and creates an OpenAPI External Documentation Object
+ * if the URL is present.
+ */
+export function processExternalDocs(collection) {
+    try {
+        const urlVariable = findVariable(collection, VARIABLE_KEYS.URL);
+        const descriptionVariable = findVariable(collection, VARIABLE_KEYS.DESCRIPTION);
+        if (!urlVariable?.value) {
+            return undefined;
+        }
+        if (typeof urlVariable.value !== 'string') {
+            throw new Error('External docs URL must be a string');
+        }
+        return {
+            url: urlVariable.value,
+            ...(descriptionVariable?.value &&
+                typeof descriptionVariable.value === 'string' && {
+                description: descriptionVariable.value,
+            }),
+        };
     }
-    if (typeof urlVariable.value !== "string") {
-      throw new Error("External docs URL must be a string");
+    catch (error) {
+        console.error('Error processing external docs:', error);
+        throw error;
     }
-    return {
-      url: urlVariable.value,
-      ...descriptionVariable?.value && typeof descriptionVariable.value === "string" && {
-        description: descriptionVariable.value
-      }
-    };
-  } catch (error) {
-    console.error("Error processing external docs:", error);
-    throw error;
-  }
 }
-export {
-  processExternalDocs
-};
-//# sourceMappingURL=external-docs.js.map

package/dist/helpers/form-data.js

@@ -1,39 +1,45 @@
-function processFormDataSchema(formdata) {
-  const schema = {
-    type: "object",
-    properties: {},
-    required: []
-  };
-  formdata.forEach((item) => {
-    if (!schema.properties) {
-      return;
-    }
-    const property = {
-      type: "string"
+/**
+ * Processes form data parameters from a Postman request and converts them into an OpenAPI schema.
+ * Handles file uploads, required fields, and descriptions.
+ */
+export function processFormDataSchema(formdata) {
+    const schema = {
+        type: 'object',
+        properties: {},
+        required: [],
     };
-    if (item.description) {
-      const descriptionText = typeof item.description === "string" ? item.description : item.description.content || "";
-      property.description = descriptionText.replace(" [required]", "");
-      if (descriptionText.includes("[required]")) {
-        schema.required?.push(item.key);
-      }
-    }
-    if (item.type === "file") {
-      property.format = "binary";
-    } else {
-      property.example = item.value;
-    }
-    if (item.disabled === true) {
-      property["x-scalar-disabled"] = true;
+    formdata.forEach((item) => {
+        if (!schema.properties) {
+            return;
+        }
+        const property = {
+            type: 'string',
+        };
+        // Add description if present, handling both string and object descriptions
+        if (item.description) {
+            const descriptionText = typeof item.description === 'string' ? item.description : item.description.content || '';
+            property.description = descriptionText.replace(' [required]', '');
+            // If [required] was present, add to required array
+            if (descriptionText.includes('[required]')) {
+                schema.required?.push(item.key);
+            }
+        }
+        // Handle file type fields
+        if (item.type === 'file') {
+            property.format = 'binary';
+        }
+        else {
+            property.example = item.value;
+        }
+        // Add x-scalar-disabled extension if parameter is disabled
+        if (item.disabled === true) {
+            property['x-scalar-disabled'] = true;
+        }
+        schema.properties[item.key] = property;
+    });
+    // Only keep required array if it has items
+    if (schema.required?.length === 0) {
+        delete schema.required;
     }
-    schema.properties[item.key] = property;
-  });
-  if (schema.required?.length === 0) {
-    delete schema.required;
-  }
-  return schema;
+    return schema;
 }
-export {
-  processFormDataSchema
-};
-//# sourceMappingURL=form-data.js.map

package/dist/helpers/license.js

@@ -1,22 +1,26 @@
+// Constants for license variable keys
 const VARIABLE_KEYS = {
-  NAME: "license.name",
-  URL: "license.url"
+    NAME: 'license.name',
+    URL: 'license.url',
 };
+/**
+ * Finds a specific variable in the collection by its key
+ */
 function findVariable(collection, key) {
-  return collection.variable?.find((v) => v.key === key);
+    return collection.variable?.find((v) => v.key === key);
 }
-function processLicense(collection) {
-  const nameVar = findVariable(collection, VARIABLE_KEYS.NAME);
-  if (!nameVar?.value || typeof nameVar.value !== "string") {
-    return void 0;
-  }
-  const urlVar = findVariable(collection, VARIABLE_KEYS.URL);
-  return {
-    name: nameVar.value,
-    ...urlVar?.value && typeof urlVar.value === "string" && { url: urlVar.value }
-  };
+/**
+ * Processes license information from collection variables.
+ * Returns an OpenAPI License Object if the license name is present.
+ */
+export function processLicense(collection) {
+    const nameVar = findVariable(collection, VARIABLE_KEYS.NAME);
+    if (!nameVar?.value || typeof nameVar.value !== 'string') {
+        return undefined;
+    }
+    const urlVar = findVariable(collection, VARIABLE_KEYS.URL);
+    return {
+        name: nameVar.value,
+        ...(urlVar?.value && typeof urlVar.value === 'string' && { url: urlVar.value }),
+    };
 }
-export {
-  processLicense
-};
-//# sourceMappingURL=license.js.map

package/dist/helpers/logo.js

@@ -1,23 +1,24 @@
-function processLogo(postmanCollection) {
-  const logoVariables = postmanCollection.variable?.filter((v) => v.key?.startsWith("x-logo.")) || [];
-  if (logoVariables.length === 0) {
-    return null;
-  }
-  const logo = {};
-  logoVariables.forEach((v) => {
-    if (v.key) {
-      const key = v.key.replace("x-logo.", "").replace("Var", "");
-      logo[key] = v.value;
+/**
+ * Processes logo information from a Postman Collection.
+ * This function extracts logo-related variables from the collection
+ * and constructs an object with logo properties.
+ */
+export function processLogo(postmanCollection) {
+    const logoVariables = postmanCollection.variable?.filter((v) => v.key?.startsWith('x-logo.')) || [];
+    if (logoVariables.length === 0) {
+        return null;
     }
-  });
-  return {
-    url: logo.url,
-    backgroundColor: logo.backgroundColor,
-    altText: logo.altText,
-    href: logo.href
-  };
+    const logo = {};
+    logoVariables.forEach((v) => {
+        if (v.key) {
+            const key = v.key.replace('x-logo.', '').replace('Var', '');
+            logo[key] = v.value;
+        }
+    });
+    return {
+        url: logo.url,
+        backgroundColor: logo.backgroundColor,
+        altText: logo.altText,
+        href: logo.href,
+    };
 }
-export {
-  processLogo
-};
-//# sourceMappingURL=logo.js.map

package/dist/helpers/markdown.js

@@ -1,32 +1,35 @@
-const supHeaders = ["object", "name", "description", "example", "type", "required"];
-function parseMdTable(md) {
-  const lines = md.split("\n").filter((line) => line.trim() !== "");
-  if (typeof lines[0] === "undefined" || lines.length < 3) {
-    return {};
-  }
-  const header = lines[0].split("|").map((cell) => cell.trim()).filter(Boolean);
-  if (!header.includes("object") || !header.includes("name")) {
-    return {};
-  }
-  const headers = header.map((h) => supHeaders.includes(h) ? h : false);
-  const rows = lines.slice(2).map(
-    (line) => line.split("|").map((cell) => cell.trim()).filter(Boolean)
-  );
-  const tableObj = rows.reduce((accTable, cell) => {
-    const cellObj = cell.reduce((accCell, field, index) => {
-      if (headers[index] && typeof headers[index] === "string") {
-        accCell[headers[index]] = field;
-      }
-      return accCell;
-    }, {});
-    if (cellObj.name) {
-      accTable[cellObj.name] = cellObj;
+const supHeaders = ['object', 'name', 'description', 'example', 'type', 'required'];
+/**
+ * Parses a Markdown table and returns an object representation.
+ */
+export function parseMdTable(md) {
+    const lines = md.split('\n').filter((line) => line.trim() !== '');
+    if (typeof lines[0] === 'undefined' || lines.length < 3) {
+        return {};
+    }
+    const header = lines[0]
+        .split('|')
+        .map((cell) => cell.trim())
+        .filter(Boolean);
+    if (!header.includes('object') || !header.includes('name')) {
+        return {};
     }
-    return accTable;
-  }, {});
-  return tableObj;
+    const headers = header.map((h) => (supHeaders.includes(h) ? h : false));
+    const rows = lines.slice(2).map((line) => line
+        .split('|')
+        .map((cell) => cell.trim())
+        .filter(Boolean));
+    const tableObj = rows.reduce((accTable, cell) => {
+        const cellObj = cell.reduce((accCell, field, index) => {
+            if (headers[index] && typeof headers[index] === 'string') {
+                accCell[headers[index]] = field;
+            }
+            return accCell;
+        }, {});
+        if (cellObj.name) {
+            accTable[cellObj.name] = cellObj;
+        }
+        return accTable;
+    }, {});
+    return tableObj;
 }
-export {
-  parseMdTable
-};
-//# sourceMappingURL=markdown.js.map