@mintlify/cli 4.0.1477 → 4.0.1479

package/__test__/openApiCheck.test.ts

@@ -6,11 +6,24 @@ import { readLocalOpenApiFile } from '../src/helpers.js';
 import { getOpenApiFilenamesFromDocsConfig } from '../src/openApiCheck.js';
 import { mockValidOpenApiDocument, runCommand } from './utils.js';
 
-vi.mock('@mintlify/common', () => ({
-  getOpenApiDocumentFromUrl: vi.fn(),
-  isAllowedLocalSchemaUrl: vi.fn(),
-  validate: vi.fn(),
-}));
+vi.mock('@mintlify/common', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('@mintlify/common')>();
+  return {
+    ...mod,
+    getOpenApiDocumentFromUrl: vi.fn(),
+    isAllowedLocalSchemaUrl: vi.fn(),
+    validate: vi.fn(),
+  };
+});
+
+vi.mock('@mintlify/prebuild', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('@mintlify/prebuild')>();
+  return {
+    ...mod,
+    getMintIgnore: vi.fn(async () => []),
+    discoverOverlayFiles: vi.fn(async () => []),
+  };
+});
 
 vi.mock('@mintlify/previewing', async (importOriginal) => {
   const mod = await importOriginal<typeof import('@mintlify/previewing')>();

package/bin/cli.js

@@ -32,7 +32,7 @@ import { logout } from './logout.js';
 import { mdxLinter } from './mdxLinter.js';
 import { createTelemetryMiddleware } from './middlewares/telemetryMiddleware.js';
 import { mintTestHandler } from './mintTest.js';
-import { checkOpenApiFile, getOpenApiFilenamesFromDocsConfig } from './openApiCheck.js';
+import { buildOverlayRegistryForCheck, checkOpenApiFile, getOpenApiFilenamesFromDocsConfig, } from './openApiCheck.js';
 import { resolveExplicitFiles } from './resolveFiles.js';
 import { scoreHandler } from './score/index.js';
 import { signup } from './signup.js';
@@ -191,7 +191,16 @@ export const cli = ({ packageName = 'mint' }) => {
                 openApiFilenames = getOpenApiFilenamesFromDocsConfig(JSON.parse(docsJson));
             }
             catch (_a) { }
-            const results = yield Promise.all(openApiFilenames.map((file) => checkOpenApiFile(file, argv['local-schema'])));
+            let overlayRegistry;
+            try {
+                overlayRegistry = yield buildOverlayRegistryForCheck(argv['local-schema']);
+            }
+            catch (error) {
+                addLog(_jsx(ErrorLog, { message: error instanceof Error ? error.message : String(error) }));
+                yield terminate(1);
+                return;
+            }
+            const results = yield Promise.all(openApiFilenames.map((file) => checkOpenApiFile(file, argv['local-schema'], overlayRegistry)));
             if (results.some((valid) => !valid)) {
                 yield terminate(1);
                 return;
@@ -243,7 +252,16 @@ export const cli = ({ packageName = 'mint' }) => {
         description: 'use a locally hosted schema file (note: only https protocol is supported in production)',
     }), (_a) => __awaiter(void 0, [_a], void 0, function* ({ filename, 'local-schema': localSchema }) {
         addLog(_jsx(WarningLog, { message: "openapi-check is deprecated, use `mintlify validate` instead" }));
-        const valid = yield checkOpenApiFile(filename, localSchema);
+        let overlayRegistry;
+        try {
+            overlayRegistry = yield buildOverlayRegistryForCheck(localSchema);
+        }
+        catch (error) {
+            addLog(_jsx(ErrorLog, { message: error instanceof Error ? error.message : String(error) }));
+            yield terminate(1);
+            return;
+        }
+        const valid = yield checkOpenApiFile(filename, localSchema, overlayRegistry);
         yield terminate(valid ? 0 : 1);
     }))
         .command('broken-links', 'Check for broken links', (yargs) => yargs

package/bin/openApiCheck.js

@@ -8,24 +8,56 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { jsx as _jsx } from "react/jsx-runtime";
-import { validate, getOpenApiDocumentFromUrl, isAllowedLocalSchemaUrl } from '@mintlify/common';
+import { applyOverlays, createOverlayRegistry, getOpenApiDocumentFromUrl, isAllowedLocalSchemaUrl, resolveOverlaysForSpec, validate, } from '@mintlify/common';
+import { discoverOverlayFiles, getMintIgnore, resolveFileRefs } from '@mintlify/prebuild';
 import { addLog, ErrorLog, SuccessLog, WarningLog } from '@mintlify/previewing';
-import { readLocalOpenApiFile } from './helpers.js';
+import { collectOpenApiOverlayConfig, extractOpenApiEntries, } from '@mintlify/validation';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { CMD_EXEC_PATH, readLocalOpenApiFile } from './helpers.js';
 export const getOpenApiFilenamesFromDocsConfig = (config) => {
     var _a;
-    const openapi = (_a = config.api) === null || _a === void 0 ? void 0 : _a.openapi;
-    if (openapi === undefined)
-        return [];
-    if (typeof openapi === 'string')
-        return [openapi];
-    if (Array.isArray(openapi))
-        return openapi;
-    return [openapi.source];
+    return extractOpenApiEntries((_a = config.api) === null || _a === void 0 ? void 0 : _a.openapi).map((entry) => entry.source);
 };
-export const checkOpenApiFile = (filename, localSchema) => __awaiter(void 0, void 0, void 0, function* () {
+/**
+ * Builds the overlay registry so checks validate specs with overlays applied.
+ * Throws when docs.json configures conflicting overlay lists, matching the build.
+ */
+export const buildOverlayRegistryForCheck = (localSchema) => __awaiter(void 0, void 0, void 0, function* () {
+    // Discovery failures propagate and fail the check: silently skipping overlays would
+    // validate a different document than the one the build produces.
+    const mintIgnore = yield getMintIgnore(CMD_EXEC_PATH);
+    const discovered = yield discoverOverlayFiles(CMD_EXEC_PATH, mintIgnore);
+    let rawConfig;
     try {
+        rawConfig = JSON.parse(yield fs.readFile(path.join(CMD_EXEC_PATH, 'docs.json'), 'utf-8'));
+    }
+    catch (_a) {
+        rawConfig = undefined;
+    }
+    if (rawConfig !== undefined) {
+        try {
+            rawConfig = (yield resolveFileRefs(rawConfig, CMD_EXEC_PATH)).resolved;
+        }
+        catch (_b) {
+            // Broken $refs are reported by regular config validation; collect from the root file.
+        }
+    }
+    const explicit = rawConfig == undefined ? undefined : collectOpenApiOverlayConfig(rawConfig);
+    if (explicit == undefined && discovered.length === 0)
+        return undefined;
+    return createOverlayRegistry({
+        explicit,
+        discovered,
+        localSchema,
+        loadLocalDocument: (normalizedPath) => readLocalOpenApiFile(normalizedPath),
+    });
+});
+export const checkOpenApiFile = (filename, localSchema, overlayRegistry) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const overlays = overlayRegistry ? yield resolveOverlaysForSpec(overlayRegistry, filename) : [];
         if (isAllowedLocalSchemaUrl(filename, localSchema)) {
-            yield getOpenApiDocumentFromUrl(filename);
+            yield getOpenApiDocumentFromUrl(filename, { overlays });
             addLog(_jsx(SuccessLog, { message: "OpenAPI definition is valid." }));
             return true;
         }
@@ -38,7 +70,11 @@ export const checkOpenApiFile = (filename, localSchema) => __awaiter(void 0, voi
         if (!document) {
             throw new Error('failed to parse OpenAPI spec: could not parse file correctly, please check for any syntax errors.');
         }
-        yield validate(document);
+        const overlaid = overlays.length > 0 ? applyOverlays(document, overlays) : document;
+        if (overlaid == undefined || typeof overlaid !== 'object') {
+            throw new Error('applying overlays produced an invalid OpenAPI document.');
+        }
+        yield validate(overlaid);
         addLog(_jsx(SuccessLog, { message: "OpenAPI definition is valid." }));
         return true;
     }