@mintlify/common 1.0.1205 → 1.0.1207

package/dist/openapi/pathItems.js

@@ -0,0 +1,97 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { getComponentNameFromRef, getPathItemOperations, isFixedHttpMethod, } from '@mintlify/validation';
+export const escapePointer = (segment) => segment.replaceAll('~', '~0').replaceAll('/', '~1');
+export const operationPointer = (method) => isFixedHttpMethod(method)
+    ? escapePointer(method)
+    : `additionalOperations/${escapePointer(method)}`;
+const REFERENCE_ONLY_KEYS = new Set(['$ref', 'summary', 'description']);
+const isBareLocalRef = (value, section, components) => {
+    var _a;
+    if (!('$ref' in value) || typeof value.$ref !== 'string')
+        return false;
+    const name = getComponentNameFromRef(value.$ref, section);
+    if (name === undefined || !((_a = components === null || components === void 0 ? void 0 : components[section]) === null || _a === void 0 ? void 0 : _a[name]))
+        return false;
+    return Object.keys(value).every((key) => REFERENCE_ONLY_KEYS.has(key));
+};
+export const resolvePathItem = (pathItem, components, seen = new Set()) => {
+    var _a;
+    if (!('$ref' in pathItem) || typeof pathItem.$ref !== 'string')
+        return pathItem;
+    const { $ref, summary, description } = pathItem, siblings = __rest(pathItem, ["$ref", "summary", "description"]);
+    const name = getComponentNameFromRef($ref, 'pathItems');
+    const key = `pathItems/${name}`;
+    const target = name !== undefined && !seen.has(key) ? (_a = components === null || components === void 0 ? void 0 : components.pathItems) === null || _a === void 0 ? void 0 : _a[name] : undefined;
+    const resolvedTarget = target
+        ? resolvePathItem(target, components, seen.add(key))
+        : {};
+    const inline = siblings;
+    const additionalOperations = resolvedTarget.additionalOperations || inline.additionalOperations
+        ? Object.assign(Object.assign({}, resolvedTarget.additionalOperations), inline.additionalOperations) : undefined;
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, resolvedTarget), inline), (additionalOperations ? { additionalOperations } : {})), (summary !== undefined ? { summary } : {})), (description !== undefined ? { description } : {}));
+};
+const resolveCallback = (callback, components, seen) => {
+    var _a;
+    if (!('$ref' in callback))
+        return callback;
+    if (typeof callback.$ref !== 'string')
+        return undefined;
+    const name = getComponentNameFromRef(callback.$ref, 'callbacks');
+    const key = `callbacks/${name}`;
+    if (name === undefined || seen.has(key))
+        return undefined;
+    const target = (_a = components === null || components === void 0 ? void 0 : components.callbacks) === null || _a === void 0 ? void 0 : _a[name];
+    return target ? resolveCallback(target, components, seen.add(key)) : undefined;
+};
+export const forEachPathItem = (document, visit) => {
+    var _a, _b;
+    const { components } = document;
+    const visitCallback = (location, raw, chain) => {
+        if (isBareLocalRef(raw, 'callbacks', components))
+            return;
+        const seen = new Set(chain);
+        const callback = resolveCallback(raw, components, seen);
+        for (const [expression, item] of Object.entries(callback !== null && callback !== void 0 ? callback : {})) {
+            visitPathItem(`${location}/${escapePointer(expression)}`, item, seen);
+        }
+    };
+    const visitPathItem = (location, raw, chain) => {
+        var _a;
+        if (isBareLocalRef(raw, 'pathItems', components))
+            return;
+        const seen = new Set(chain);
+        const pathItem = resolvePathItem(raw, components, seen);
+        visit(location, pathItem);
+        for (const [method, operation] of getPathItemOperations(pathItem)) {
+            for (const [name, rawCallback] of Object.entries((_a = operation.callbacks) !== null && _a !== void 0 ? _a : {})) {
+                visitCallback(`${location}/${operationPointer(method)}/callbacks/${escapePointer(name)}`, rawCallback, seen);
+            }
+        }
+    };
+    for (const [name, item] of Object.entries((_a = components === null || components === void 0 ? void 0 : components.pathItems) !== null && _a !== void 0 ? _a : {})) {
+        visitPathItem(`/components/pathItems/${escapePointer(name)}`, item, new Set([`pathItems/${name}`]));
+    }
+    for (const [name, callback] of Object.entries((_b = components === null || components === void 0 ? void 0 : components.callbacks) !== null && _b !== void 0 ? _b : {})) {
+        visitCallback(`/components/callbacks/${escapePointer(name)}`, callback, new Set([`callbacks/${name}`]));
+    }
+    const roots = [
+        ['/paths', document.paths],
+        ['/webhooks', document.webhooks],
+    ];
+    for (const [prefix, entries] of roots) {
+        for (const [key, item] of Object.entries(entries !== null && entries !== void 0 ? entries : {})) {
+            if (item)
+                visitPathItem(`${prefix}/${escapePointer(key)}`, item, new Set());
+        }
+    }
+};

package/dist/openapi/querystringParameters.d.ts

@@ -1,5 +1,3 @@
-import { type OpenAPIV3_2 } from '@mintlify/validation';
+import { type PathItemSources } from './pathItems.js';
 import type { OpenApiValidateError } from './validate.js';
-type PathItemSources = Partial<Pick<OpenAPIV3_2.Document, 'paths' | 'webhooks' | 'components'>>;
 export declare const validateQuerystringParameters: (document: PathItemSources) => OpenApiValidateError[];
-export {};

package/dist/openapi/querystringParameters.js

@@ -1,22 +1,10 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { getPathItemOperations, isFixedHttpMethod } from '@mintlify/validation';
-const escapePointer = (segment) => segment.replaceAll('~', '~0').replaceAll('/', '~1');
-const componentName = (ref, section) => { var _a; return (_a = new RegExp(`^#/components/${section}/(.+)$`).exec(ref)) === null || _a === void 0 ? void 0 : _a[1]; };
+import { getComponentNameFromRef, getPathItemOperations, isFixedHttpMethod, } from '@mintlify/validation';
+import { escapePointer, forEachPathItem } from './pathItems.js';
 const resolveParameter = (parameter, components, seen = new Set()) => {
     var _a;
     if (!('$ref' in parameter))
         return parameter;
-    const name = componentName(parameter.$ref, 'parameters');
+    const name = getComponentNameFromRef(parameter.$ref, 'parameters');
     if (name === undefined || seen.has(name))
         return undefined;
     const resolved = (_a = components === null || components === void 0 ? void 0 : components.parameters) === null || _a === void 0 ? void 0 : _a[name];
@@ -27,37 +15,13 @@ const querystringNames = (parameters, components) => new Set(parameters.flatMap(
     const resolved = resolveParameter(parameter, components);
     return (resolved === null || resolved === void 0 ? void 0 : resolved.in) === 'querystring' ? [resolved.name] : [];
 }));
-const resolvePathItem = (pathItem, components, seen = new Set()) => {
-    var _a;
-    if (!('$ref' in pathItem) || typeof pathItem.$ref !== 'string')
-        return pathItem;
-    const { $ref, summary, description } = pathItem, siblings = __rest(pathItem, ["$ref", "summary", "description"]);
-    const name = componentName($ref, 'pathItems');
-    const target = name !== undefined && !seen.has(name) ? (_a = components === null || components === void 0 ? void 0 : components.pathItems) === null || _a === void 0 ? void 0 : _a[name] : undefined;
-    const resolvedTarget = target && name !== undefined ? resolvePathItem(target, components, seen.add(name)) : {};
-    return Object.assign(Object.assign(Object.assign({}, resolvedTarget), siblings), { summary, description });
-};
 export const validateQuerystringParameters = (document) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
     const errors = [];
-    const pathItems = [
-        ...Object.entries((_a = document.paths) !== null && _a !== void 0 ? _a : {}).map(([path, item]) => [`/paths/${escapePointer(path)}`, item]),
-        ...Object.entries((_b = document.webhooks) !== null && _b !== void 0 ? _b : {}).map(([name, item]) => [
-            `/webhooks/${escapePointer(name)}`,
-            item,
-        ]),
-        ...Object.entries((_d = (_c = document.components) === null || _c === void 0 ? void 0 : _c.pathItems) !== null && _d !== void 0 ? _d : {}).map(([name, item]) => [
-            `/components/pathItems/${escapePointer(name)}`,
-            item,
-        ]),
-    ];
-    for (const [location, rawPathItem] of pathItems) {
-        if (!rawPathItem)
-            continue;
-        const pathItem = resolvePathItem(rawPathItem, document.components);
-        const pathLocations = ((_e = pathItem.parameters) !== null && _e !== void 0 ? _e : []).map((parameter) => parameterLocation(parameter, document.components));
+    forEachPathItem(document, (location, pathItem) => {
+        var _a, _b, _c, _d;
+        const pathLocations = ((_a = pathItem.parameters) !== null && _a !== void 0 ? _a : []).map((parameter) => parameterLocation(parameter, document.components));
         for (const [method, operation] of getPathItemOperations(pathItem)) {
-            const operationLocations = ((_f = operation.parameters) !== null && _f !== void 0 ? _f : []).map((parameter) => parameterLocation(parameter, document.components));
+            const operationLocations = ((_b = operation.parameters) !== null && _b !== void 0 ? _b : []).map((parameter) => parameterLocation(parameter, document.components));
             const locations = [...pathLocations, ...operationLocations];
             const operationPointer = isFixedHttpMethod(method)
                 ? escapePointer(method)
@@ -68,7 +32,7 @@ export const validateQuerystringParameters = (document) => {
                     message: 'in: querystring cannot be combined with in: query parameters on the same operation',
                 });
             }
-            const names = querystringNames([...((_g = pathItem.parameters) !== null && _g !== void 0 ? _g : []), ...((_h = operation.parameters) !== null && _h !== void 0 ? _h : [])], document.components);
+            const names = querystringNames([...((_c = pathItem.parameters) !== null && _c !== void 0 ? _c : []), ...((_d = operation.parameters) !== null && _d !== void 0 ? _d : [])], document.components);
             if (names.size > 1) {
                 errors.push({
                     path: `${location}/${operationPointer}/parameters`,
@@ -76,6 +40,6 @@ export const validateQuerystringParameters = (document) => {
                 });
             }
         }
-    }
+    });
     return errors;
 };

package/dist/openapi/servers.d.ts

@@ -0,0 +1,6 @@
+import { type OpenAPIV3_2 } from '@mintlify/validation';
+import { type PathItemSources } from './pathItems.js';
+import type { OpenApiValidateError } from './validate.js';
+type ServerSources = PathItemSources & Partial<Pick<OpenAPIV3_2.Document, 'servers'>>;
+export declare const validateServerUrls: (document: ServerSources) => OpenApiValidateError[];
+export {};

package/dist/openapi/servers.js

@@ -0,0 +1,50 @@
+import { getPathItemOperations } from '@mintlify/validation';
+import { escapePointer, forEachPathItem, operationPointer, } from './pathItems.js';
+const duplicateVariables = (url) => {
+    var _a;
+    const seen = new Map();
+    for (const match of url.matchAll(/\{([^{}]+)\}/g)) {
+        const name = match[1];
+        if (name !== undefined)
+            seen.set(name, ((_a = seen.get(name)) !== null && _a !== void 0 ? _a : 0) + 1);
+    }
+    return [...seen.entries()].filter(([, count]) => count > 1).map(([name]) => name);
+};
+export const validateServerUrls = (document) => {
+    var _a, _b;
+    const errors = [];
+    const checkServer = (location, server) => {
+        if (!server)
+            return;
+        for (const name of duplicateVariables(server.url)) {
+            errors.push({
+                path: `${location}/url`,
+                message: `Server variable {${name}} appears more than once in the URL`,
+            });
+        }
+    };
+    const checkServers = (location, servers) => servers === null || servers === void 0 ? void 0 : servers.forEach((server, index) => checkServer(`${location}/${index}`, server));
+    const checkLinks = (location, links) => {
+        for (const [name, link] of Object.entries(links !== null && links !== void 0 ? links : {})) {
+            if (!('$ref' in link))
+                checkServer(`${location}/${escapePointer(name)}/server`, link.server);
+        }
+    };
+    const checkResponses = (location, responses) => {
+        for (const [code, response] of Object.entries(responses !== null && responses !== void 0 ? responses : {})) {
+            if (!('$ref' in response))
+                checkLinks(`${location}/${escapePointer(code)}/links`, response.links);
+        }
+    };
+    checkServers('/servers', document.servers);
+    checkLinks('/components/links', (_a = document.components) === null || _a === void 0 ? void 0 : _a.links);
+    checkResponses('/components/responses', (_b = document.components) === null || _b === void 0 ? void 0 : _b.responses);
+    forEachPathItem(document, (location, pathItem) => {
+        checkServers(`${location}/servers`, pathItem.servers);
+        for (const [method, operation] of getPathItemOperations(pathItem)) {
+            checkServers(`${location}/${operationPointer(method)}/servers`, operation.servers);
+            checkResponses(`${location}/${operationPointer(method)}/responses`, operation.responses);
+        }
+    });
+    return errors;
+};

package/dist/openapi/validate.js

@@ -8,12 +8,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { getEntrypoint, normalize, validate as scalarValidate } from '@mintlify/openapi-parser';
+import { isComponentPathItemReference, resolvePathItemReference } from '@mintlify/validation';
 import { checkForExternalRefs } from '../asyncapi/checkForExternalRefs.js';
 import { validateAdditionalOperations } from './additionalOperations.js';
+import { validateDiscriminatorDefaults } from './discriminators.js';
+import { validatePositionalEncodings } from './encodings.js';
+import { validateHeaderNames } from './headerNames.js';
 import { validateQuerystringParameters } from './querystringParameters.js';
+import { validateServerUrls } from './servers.js';
 import { validateOpenApiTagTree } from './tagHierarchy.js';
 export const isOpenApi32Version = (version) => typeof version === 'string' && /^3\.2(\.|$)/.test(version);
 export const getEntrypointSpecification = (document) => { var _a; return Array.isArray(document) ? (_a = getEntrypoint(document)) === null || _a === void 0 ? void 0 : _a.specification : document; };
+const inlineComponentPathItemReferences = (document, specification) => {
+    var _a;
+    if (typeof specification.openapi !== 'string' || !/^3\.[12](\.|$)/.test(specification.openapi))
+        return document;
+    const sections = ['paths', 'webhooks'].flatMap((section) => {
+        const entries = specification[section];
+        if (typeof entries !== 'object' || entries === null)
+            return [];
+        const referenced = Object.keys(entries).filter((key) => isComponentPathItemReference(entries[key]));
+        return referenced.length > 0 ? [{ section, referenced }] : [];
+    });
+    if (sections.length === 0)
+        return document;
+    const inlined = structuredClone(specification);
+    for (const { section, referenced } of sections) {
+        const entries = inlined[section];
+        for (const key of referenced) {
+            const item = entries[key];
+            if (typeof item !== 'object' || item === null)
+                continue;
+            entries[key] = (_a = resolvePathItemReference(item, inlined.components)) !== null && _a !== void 0 ? _a : item;
+        }
+    }
+    if (!Array.isArray(document))
+        return inlined;
+    return document.map((entry) => entry.specification === specification ? Object.assign(Object.assign({}, entry), { specification: inlined }) : entry);
+};
 const validateOpenApi32 = (document, specification) => __awaiter(void 0, void 0, void 0, function* () {
     const outcome = yield scalarValidate(document);
     if (!outcome.valid)
@@ -22,6 +54,10 @@ const validateOpenApi32 = (document, specification) => __awaiter(void 0, void 0,
         ...validateOpenApiTagTree(specification.tags).map((message) => ({ path: '/tags', message })),
         ...validateAdditionalOperations(specification),
         ...validateQuerystringParameters(specification),
+        ...validateDiscriminatorDefaults(specification),
+        ...validatePositionalEncodings(specification),
+        ...validateHeaderNames(specification),
+        ...validateServerUrls(specification),
     ];
     if (structuralErrors.length > 0) {
         return { valid: false, version: '3.2', errors: structuralErrors };
@@ -47,9 +83,12 @@ export const safeValidate = (document) => __awaiter(void 0, void 0, void 0, func
     const normalized = normalize(document);
     const specification = getEntrypointSpecification(normalized);
     const openApi32Specification = specification && isOpenApi32Version(specification.openapi) ? specification : undefined;
+    const inlined = specification
+        ? inlineComponentPathItemReferences(normalized, specification)
+        : normalized;
     const result = openApi32Specification
-        ? yield validateOpenApi32(normalized, openApi32Specification)
-        : yield scalarValidate(normalized);
+        ? yield validateOpenApi32(inlined, openApi32Specification)
+        : yield scalarValidate(inlined);
     const { errors, schema, valid, version } = result;
     if (version === '2.0')
         return Object.assign(Object.assign({}, result), { errorMessage: 'OpenAPI versions prior to 3.0 not supported', valid: false });