@mintlify/common 1.0.1202 → 1.0.1204

package/dist/openapi/tagHierarchy.js

@@ -0,0 +1,101 @@
+import { getTagDisplayName } from './getTagDisplayName.js';
+import { isOpenApi32Version } from './validate.js';
+export const isOpenApi32 = (schema) => 'openapi' in schema && isOpenApi32Version(schema.openapi);
+export function validateOpenApiTagTree(tags = []) {
+    const errors = [];
+    const byName = new Map();
+    for (const tag of tags) {
+        if (byName.has(tag.name))
+            errors.push(`Duplicate OpenAPI tag name: ${tag.name}`);
+        byName.set(tag.name, tag);
+    }
+    for (const tag of tags) {
+        if (tag.parent !== undefined && !byName.has(tag.parent)) {
+            errors.push(`OpenAPI tag ${tag.name} has unknown parent: ${tag.parent}`);
+        }
+    }
+    const reachesRoot = new Set();
+    for (const tag of tags) {
+        const seen = new Set();
+        let current = tag;
+        let circular = false;
+        while ((current === null || current === void 0 ? void 0 : current.parent) !== undefined && !reachesRoot.has(current.name)) {
+            if (seen.has(current.name)) {
+                errors.push(`Circular OpenAPI tag parent reference: ${current.name}`);
+                circular = true;
+                break;
+            }
+            seen.add(current.name);
+            current = byName.get(current.parent);
+        }
+        if (!circular)
+            seen.forEach((name) => reachesRoot.add(name));
+    }
+    return errors;
+}
+export function createOpenApiTagResolver(schema) {
+    var _a;
+    const tags = (_a = schema.tags) !== null && _a !== void 0 ? _a : [];
+    const nested = isOpenApi32(schema);
+    const byName = new Map(tags.map((tag) => [tag.name, tag]));
+    const paths = new Map();
+    function resolvePath(name) {
+        var _a;
+        const cached = paths.get(name);
+        if (cached)
+            return cached;
+        const path = [];
+        const ancestors = new Set();
+        let current = name;
+        while (current !== undefined && !ancestors.has(current)) {
+            ancestors.add(current);
+            const tag = byName.get(current);
+            if ((tag === null || tag === void 0 ? void 0 : tag.kind) === undefined || tag.kind === 'nav' || current === name) {
+                path.push({
+                    name: current,
+                    label: (_a = tag === null || tag === void 0 ? void 0 : tag['x-group']) !== null && _a !== void 0 ? _a : ((tag === null || tag === void 0 ? void 0 : tag.summary) || current),
+                    key: current,
+                });
+            }
+            current = (tag === null || tag === void 0 ? void 0 : tag.parent) !== undefined && byName.has(tag.parent) ? tag.parent : undefined;
+        }
+        path.reverse();
+        paths.set(name, path);
+        return path;
+    }
+    const kindOf = (name) => { var _a, _b; return byName.has(name) ? ((_b = (_a = byName.get(name)) === null || _a === void 0 ? void 0 : _a.kind) !== null && _b !== void 0 ? _b : 'none') : 'undeclared'; };
+    return (operationTags = []) => {
+        var _a, _b, _c;
+        const name = nested
+            ? ((_b = (_a = operationTags.find((name) => kindOf(name) === 'nav')) !== null && _a !== void 0 ? _a : operationTags.find((name) => kindOf(name) === 'none')) !== null && _b !== void 0 ? _b : operationTags.find((name) => kindOf(name) === 'undeclared'))
+            : operationTags[0];
+        if (name === undefined || (!nested && !name))
+            return [];
+        if (!nested)
+            return [{ name, label: (_c = getTagDisplayName(name, schema)) !== null && _c !== void 0 ? _c : name }];
+        return resolvePath(name);
+    };
+}
+export function createOpenApiBadgeResolver(schema) {
+    var _a;
+    if (!isOpenApi32(schema))
+        return () => undefined;
+    const badges = new Map();
+    for (const tag of ((_a = schema.tags) !== null && _a !== void 0 ? _a : [])) {
+        if (tag.kind === 'badge')
+            badges.set(tag.name, tag.summary || tag.name);
+    }
+    return (operationTags = []) => {
+        for (const name of operationTags) {
+            const label = badges.get(name);
+            if (label !== undefined)
+                return label;
+        }
+        return undefined;
+    };
+}
+export function findOpenApiNavGroup(nav, tagPath, findGroup) {
+    if (tagPath.length === 0)
+        return findGroup(nav);
+    return tagPath.reduce((pages, tag) => findGroup(pages, tag.label, tag.key), nav);
+}

package/dist/openapi/validate.js

@@ -7,10 +7,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { getEntrypoint, validate as scalarValidate } from '@mintlify/openapi-parser';
+import { getEntrypoint, normalize, validate as scalarValidate } from '@mintlify/openapi-parser';
 import { checkForExternalRefs } from '../asyncapi/checkForExternalRefs.js';
+import { validateAdditionalOperations } from './additionalOperations.js';
+import { validateQuerystringParameters } from './querystringParameters.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 validateOpenApi32 = (document, specification) => __awaiter(void 0, void 0, void 0, function* () {
+    const outcome = yield scalarValidate(document);
+    if (!outcome.valid)
+        return Object.assign(Object.assign({}, outcome), { version: '3.2' });
+    const structuralErrors = [
+        ...validateOpenApiTagTree(specification.tags).map((message) => ({ path: '/tags', message })),
+        ...validateAdditionalOperations(specification),
+        ...validateQuerystringParameters(specification),
+    ];
+    if (structuralErrors.length > 0) {
+        return { valid: false, version: '3.2', errors: structuralErrors };
+    }
+    return Object.assign(Object.assign({}, outcome), { version: '3.2' });
+});
 export const validate = (document) => __awaiter(void 0, void 0, void 0, function* () {
     const result = yield safeValidate(document);
     if ('errorMessage' in result) {
@@ -27,7 +44,12 @@ export const safeValidate = (document) => __awaiter(void 0, void 0, void 0, func
         const errorMessage = error instanceof Error ? error.message : String(error);
         return { errors: [{ message: errorMessage }], valid: false, errorMessage };
     }
-    const result = yield scalarValidate(document);
+    const normalized = normalize(document);
+    const specification = getEntrypointSpecification(normalized);
+    const openApi32Specification = specification && isOpenApi32Version(specification.openapi) ? specification : undefined;
+    const result = openApi32Specification
+        ? yield validateOpenApi32(normalized, openApi32Specification)
+        : yield scalarValidate(normalized);
     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 });