@mintlify/prebuild 1.0.404 → 1.0.405

package/dist/prebuild/categorizeFilePaths.d.ts

@@ -1,8 +1,10 @@
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
 import { OpenApiFile } from '@mintlify/models';
 export declare const categorizeFilePaths: (contentDirectoryPath: string) => Promise<{
     contentFilenames: string[];
     staticFilenames: string[];
     openApiFiles: OpenApiFile[];
+    asyncApiFiles: AsyncAPIFile[];
     snippets: string[];
     snippetsV2: string[];
 }>;

package/dist/prebuild/categorizeFilePaths.js

@@ -1,4 +1,5 @@
 import { openApiCheck } from '@mintlify/common';
+import { asyncApiCheck } from '@mintlify/common/asyncapi';
 import { readFile } from 'fs/promises';
 import yaml from 'js-yaml';
 import * as path from 'path';
@@ -9,6 +10,7 @@ export const categorizeFilePaths = async (contentDirectoryPath) => {
     const contentFilenames = [];
     const staticFilenames = [];
     const openApiFiles = [];
+    const asyncApiFiles = [];
     const snippets = [];
     const snippetsV2 = [];
     for await (const filename of allFilesInCmdExecutionPath) {
@@ -33,20 +35,31 @@ export const categorizeFilePaths = async (contentDirectoryPath) => {
                     // we need to read from the fs so we can store the original spec
                     const str = await readFile(path.join(contentDirectoryPath, filename), 'utf8');
                     const obj = yaml.load(str);
-                    if (!(await openApiCheck(obj)))
+                    const isOpenApi = await openApiCheck(obj);
+                    const isAsyncApi = await asyncApiCheck(obj);
+                    if (!isOpenApi && !isAsyncApi)
                         break;
                     const fileName = path.parse(filename).name;
-                    openApiFiles.push({
-                        filename: fileName,
-                        spec: obj,
-                        originalFileLocation: filename,
-                    });
+                    if (isOpenApi) {
+                        openApiFiles.push({
+                            filename: fileName,
+                            spec: obj,
+                            originalFileLocation: filename,
+                        });
+                    }
+                    if (isAsyncApi) {
+                        asyncApiFiles.push({
+                            filename: fileName,
+                            spec: obj,
+                            originalFileLocation: filename,
+                        });
+                    }
                 }
-                catch { } // not an openapi spec
+                catch { }
                 break;
             default:
                 staticFilenames.push(filename);
         }
     }
-    return { contentFilenames, staticFilenames, openApiFiles, snippets, snippetsV2 };
+    return { contentFilenames, staticFilenames, openApiFiles, asyncApiFiles, snippets, snippetsV2 };
 };

package/dist/prebuild/index.js

@@ -11,8 +11,17 @@ export const prebuild = async (contentDirectoryPath) => {
     if (mintConfigPath == null && docsConfigPath == null) {
         throw Error('Must be run in a directory where a mint.json or docs.json file exists.');
     }
-    const { contentFilenames, staticFilenames, openApiFiles, snippets, snippetsV2 } = await categorizeFilePaths(contentDirectoryPath);
-    await update(contentDirectoryPath, staticFilenames, openApiFiles, contentFilenames, snippets, snippetsV2, docsConfigPath);
+    const { contentFilenames, staticFilenames, openApiFiles, asyncApiFiles, snippets, snippetsV2 } = await categorizeFilePaths(contentDirectoryPath);
+    await update({
+        contentDirectoryPath,
+        staticFilenames,
+        openApiFiles,
+        asyncApiFiles,
+        contentFilenames,
+        snippets,
+        snippetV2Filenames: snippetsV2,
+        docsConfigPath,
+    });
 };
 export * from './categorizeFilePaths.js';
 export * from '../createPage/index.js';

package/dist/prebuild/update/docsConfig/generateOpenApiDivisions.d.ts

@@ -1,15 +1,7 @@
 import type { OpenApiFile, DecoratedNavigationPage } from '@mintlify/models';
-import { DocsConfig, NavigationConfig } from '@mintlify/validation';
+import { DocsConfig } from '@mintlify/validation';
 export declare const generateOpenApiDivisions: (docsConfig: DocsConfig, openApiFiles: OpenApiFile[], targetDir?: string) => Promise<{
     newDocsConfig: DocsConfig;
     pagesAcc: Record<string, DecoratedNavigationPage>;
     openApiFiles: OpenApiFile[];
 }>;
-export declare const generateOpenApiFromDocsConfig: (navigation: NavigationConfig, openApiFiles: OpenApiFile[], pagesAcc: Record<string, DecoratedNavigationPage>, opts: {
-    overwrite?: boolean;
-    writeFiles: boolean;
-    targetDir?: string;
-}) => Promise<{
-    newNav: NavigationConfig;
-    newOpenApiFiles: OpenApiFile[];
-}>;

package/dist/prebuild/update/docsConfig/generateOpenApiDivisions.js

@@ -1,9 +1,5 @@
-import { getOpenApiDocumentFromUrl, optionallyAddLeadingSlash } from '@mintlify/common';
-import { generateOpenApiPagesForDocsConfig } from '@mintlify/scraping';
-import { divisions, } from '@mintlify/validation';
-import * as path from 'path';
 import { getOpenApiFilesFromConfig } from '../read/getOpenApiFilesFromConfig.js';
-const DEFAULT_OUTPUT_DIR = 'api-reference';
+import { generateOpenApiFromDocsConfig } from './generateOpenApiFromDocsConfig.js';
 export const generateOpenApiDivisions = async (docsConfig, openApiFiles, targetDir) => {
     const openapiFilesFromDocsConfig = await getOpenApiFilesFromConfig('docs', docsConfig);
     openApiFiles.push(...openapiFilesFromDocsConfig);
@@ -19,125 +15,3 @@ export const generateOpenApiDivisions = async (docsConfig, openApiFiles, targetD
         openApiFiles: [...openApiFiles, ...newOpenApiFiles],
     };
 };
-export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pagesAcc, opts) => {
-    const { overwrite, writeFiles, targetDir } = opts;
-    const newOpenApiFiles = [];
-    async function processOpenApiInNav(nav) {
-        let outputDir = DEFAULT_OUTPUT_DIR;
-        let openapi;
-        if ('openapi' in nav) {
-            if (typeof nav.openapi === 'string') {
-                openapi = nav.openapi;
-            }
-            else if (Array.isArray(nav.openapi) && nav.openapi.length > 0) {
-                // TODO: handle multiple openapi files
-                openapi = nav.openapi[0];
-            }
-            else if (typeof nav.openapi === 'object' && 'source' in nav.openapi) {
-                openapi = nav.openapi.source;
-                outputDir = nav.openapi.directory ?? DEFAULT_OUTPUT_DIR;
-            }
-        }
-        if (openapi) {
-            let openApiFile = undefined;
-            if (openapi.startsWith('https')) {
-                openApiFile = await createOpenApiFile(openapi, getDivisionNav(nav)?.division ?? 'unknown');
-                openApiFile.filename = `${openApiFile.filename}-${newOpenApiFiles.length}`;
-                newOpenApiFiles.push(openApiFile);
-            }
-            else {
-                openApiFile = openApiFiles.find((file) => file.originalFileLocation != undefined &&
-                    file.originalFileLocation === optionallyAddLeadingSlash(openapi));
-            }
-            if (!openApiFile) {
-                throw new Error(`Openapi file ${openapi} defined in ${getDivisionNav(nav)
-                    ?.division} in your docs.json does not exist`);
-            }
-            const { pagesAcc: pagesAccFromGeneratedOpenApiPages, nav: navFromGeneratedOpenApiPages } = await generateOpenApiPagesForDocsConfig(openApiFile.spec, {
-                openApiFilePath: openApiFile.originalFileLocation,
-                writeFiles,
-                outDir: outputDir,
-                outDirBasePath: path.join(targetDir ?? '', 'src', '_props'),
-                overwrite,
-            });
-            Object.entries(pagesAccFromGeneratedOpenApiPages).forEach(([key, value]) => {
-                pagesAcc[key] = value;
-            });
-            const divisionNav = getDivisionNav(nav);
-            if (divisionNav?.division) {
-                return {
-                    [divisionNav.division]: divisionNav.name,
-                    ...divisionNav.nav,
-                    ...(divisionNav.division === 'group'
-                        ? {
-                            pages: 'pages' in nav
-                                ? [...nav.pages, ...navFromGeneratedOpenApiPages]
-                                : navFromGeneratedOpenApiPages,
-                        }
-                        : {
-                            groups: 'groups' in nav
-                                ? [...nav.groups, ...navFromGeneratedOpenApiPages]
-                                : navFromGeneratedOpenApiPages,
-                        }),
-                };
-            }
-        }
-        return null;
-    }
-    async function processNav(nav) {
-        const processedNav = await processOpenApiInNav(nav);
-        if (processedNav) {
-            return processedNav;
-        }
-        let newNav = { ...nav };
-        for (const division of ['groups', ...divisions]) {
-            if (division in newNav) {
-                const items = newNav[division];
-                newNav = {
-                    ...newNav,
-                    [division]: await Promise.all(items.map((item) => processNav(item))),
-                };
-            }
-        }
-        return newNav;
-    }
-    const processedNavigation = await processNav(navigation);
-    navigation = processedNavigation;
-    return {
-        newNav: processedNavigation,
-        newOpenApiFiles,
-    };
-};
-function getDivisionNav(nav) {
-    if ('openapi' in nav) {
-        const { openapi: _, ...updatedNav } = nav;
-        const divisionMap = {
-            group: 'group',
-            anchor: 'anchor',
-            tab: 'tab',
-            version: 'version',
-            language: 'language',
-            dropdown: 'dropdown',
-        };
-        const divisionType = Object.keys(divisionMap).find((key) => key in updatedNav);
-        return {
-            division: divisionMap[divisionType],
-            name: updatedNav[divisionType],
-            nav: updatedNav,
-        };
-    }
-    return undefined;
-}
-async function createOpenApiFile(openApiUrl, division) {
-    try {
-        const document = await getOpenApiDocumentFromUrl(openApiUrl);
-        return {
-            filename: `openapi-from-${division}`,
-            spec: document,
-        };
-    }
-    catch (err) {
-        console.error(err);
-        throw err;
-    }
-}

package/dist/prebuild/update/docsConfig/generateOpenApiFromDocsConfig.d.ts

@@ -0,0 +1,10 @@
+import type { OpenApiFile, DecoratedNavigationPage } from '@mintlify/models';
+import { NavigationConfig } from '@mintlify/validation';
+export declare const generateOpenApiFromDocsConfig: (navigation: NavigationConfig, openApiFiles: OpenApiFile[], pagesAcc: Record<string, DecoratedNavigationPage>, opts: {
+    overwrite?: boolean;
+    writeFiles: boolean;
+    targetDir?: string;
+}) => Promise<{
+    newNav: NavigationConfig;
+    newOpenApiFiles: OpenApiFile[];
+}>;

package/dist/prebuild/update/docsConfig/generateOpenApiFromDocsConfig.js

@@ -0,0 +1,127 @@
+import { getOpenApiDocumentFromUrl, optionallyAddLeadingSlash } from '@mintlify/common';
+import { generateOpenApiPagesForDocsConfig } from '@mintlify/scraping';
+import { divisions } from '@mintlify/validation';
+import * as path from 'path';
+const DEFAULT_OUTPUT_DIR = 'api-reference';
+export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pagesAcc, opts) => {
+    const { overwrite, writeFiles, targetDir } = opts;
+    const newOpenApiFiles = [];
+    async function processOpenApiInNav(nav) {
+        let outputDir = DEFAULT_OUTPUT_DIR;
+        let openapi;
+        if ('openapi' in nav) {
+            if (typeof nav.openapi === 'string') {
+                openapi = nav.openapi;
+            }
+            else if (Array.isArray(nav.openapi) && nav.openapi.length > 0) {
+                // TODO: handle multiple openapi files
+                openapi = nav.openapi[0];
+            }
+            else if (typeof nav.openapi === 'object' && 'source' in nav.openapi) {
+                openapi = nav.openapi.source;
+                outputDir = nav.openapi.directory ?? DEFAULT_OUTPUT_DIR;
+            }
+        }
+        if (openapi) {
+            let openApiFile = undefined;
+            if (openapi.startsWith('https')) {
+                openApiFile = await createOpenApiFile(openapi, getDivisionNav(nav)?.division ?? 'unknown');
+                openApiFile.filename = `${openApiFile.filename}-${newOpenApiFiles.length}`;
+                newOpenApiFiles.push(openApiFile);
+            }
+            else {
+                openApiFile = openApiFiles.find((file) => file.originalFileLocation != undefined &&
+                    file.originalFileLocation === optionallyAddLeadingSlash(openapi));
+            }
+            if (!openApiFile) {
+                throw new Error(`Openapi file ${openapi} defined in ${getDivisionNav(nav)
+                    ?.division} in your docs.json does not exist`);
+            }
+            const { pagesAcc: pagesAccFromGeneratedOpenApiPages, nav: navFromGeneratedOpenApiPages } = await generateOpenApiPagesForDocsConfig(openApiFile.spec, {
+                openApiFilePath: openApiFile.originalFileLocation,
+                writeFiles,
+                outDir: outputDir,
+                outDirBasePath: path.join(targetDir ?? '', 'src', '_props'),
+                overwrite,
+            });
+            Object.entries(pagesAccFromGeneratedOpenApiPages).forEach(([key, value]) => {
+                pagesAcc[key] = value;
+            });
+            const divisionNav = getDivisionNav(nav);
+            if (divisionNav?.division) {
+                return {
+                    [divisionNav.division]: divisionNav.name,
+                    ...divisionNav.nav,
+                    ...(divisionNav.division === 'group'
+                        ? {
+                            pages: 'pages' in nav
+                                ? [...nav.pages, ...navFromGeneratedOpenApiPages]
+                                : navFromGeneratedOpenApiPages,
+                        }
+                        : {
+                            groups: 'groups' in nav
+                                ? [...nav.groups, ...navFromGeneratedOpenApiPages]
+                                : navFromGeneratedOpenApiPages,
+                        }),
+                };
+            }
+        }
+        return null;
+    }
+    async function processNav(nav) {
+        const processedNav = await processOpenApiInNav(nav);
+        if (processedNav) {
+            return processedNav;
+        }
+        let newNav = { ...nav };
+        for (const division of ['groups', ...divisions]) {
+            if (division in newNav) {
+                const items = newNav[division];
+                newNav = {
+                    ...newNav,
+                    [division]: await Promise.all(items.map((item) => processNav(item))),
+                };
+            }
+        }
+        return newNav;
+    }
+    const processedNavigation = await processNav(navigation);
+    navigation = processedNavigation;
+    return {
+        newNav: processedNavigation,
+        newOpenApiFiles,
+    };
+};
+function getDivisionNav(nav) {
+    if ('openapi' in nav) {
+        const { openapi: _, ...updatedNav } = nav;
+        const divisionMap = {
+            group: 'group',
+            anchor: 'anchor',
+            tab: 'tab',
+            version: 'version',
+            language: 'language',
+            dropdown: 'dropdown',
+        };
+        const divisionType = Object.keys(divisionMap).find((key) => key in updatedNav);
+        return {
+            division: divisionMap[divisionType],
+            name: updatedNav[divisionType],
+            nav: updatedNav,
+        };
+    }
+    return undefined;
+}
+async function createOpenApiFile(openApiUrl, division) {
+    try {
+        const document = await getOpenApiDocumentFromUrl(openApiUrl);
+        return {
+            filename: `openapi-from-${division}`,
+            spec: document,
+        };
+    }
+    catch (err) {
+        console.error(err);
+        throw err;
+    }
+}

package/dist/prebuild/update/docsConfig/index.d.ts

@@ -1,8 +1,10 @@
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
 import { OpenApiFile, DecoratedNavigationPage } from '@mintlify/models';
 import { DocsConfig } from '@mintlify/validation';
-export declare function updateDocsConfigFile(contentDirectoryPath: string, openApiFiles: OpenApiFile[], docsConfig?: DocsConfig): Promise<{
+export declare function updateDocsConfigFile(contentDirectoryPath: string, openApiFiles: OpenApiFile[], _asyncApiFiles: AsyncAPIFile[], docsConfig?: DocsConfig): Promise<{
     docsConfig: DocsConfig;
     pagesAcc: Record<string, DecoratedNavigationPage>;
     newOpenApiFiles: OpenApiFile[];
 }>;
-export { generateOpenApiDivisions, generateOpenApiFromDocsConfig, } from './generateOpenApiDivisions.js';
+export { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
+export { generateOpenApiFromDocsConfig } from './generateOpenApiFromDocsConfig.js';

package/dist/prebuild/update/docsConfig/index.js

@@ -1,7 +1,7 @@
 import { getConfigPath } from '../../../utils.js';
 import { DocsConfigUpdater } from '../ConfigUpdater.js';
 import { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
-export async function updateDocsConfigFile(contentDirectoryPath, openApiFiles, docsConfig) {
+export async function updateDocsConfigFile(contentDirectoryPath, openApiFiles, _asyncApiFiles, docsConfig) {
     const configPath = await getConfigPath(contentDirectoryPath, 'docs');
     if (configPath == null && docsConfig == null) {
         throw Error('Must be run in a directory where a docs.json file exists.');
@@ -16,4 +16,5 @@ export async function updateDocsConfigFile(contentDirectoryPath, openApiFiles, d
     await DocsConfigUpdater.writeConfigFile(newDocsConfig);
     return { docsConfig: newDocsConfig, pagesAcc, newOpenApiFiles };
 }
-export { generateOpenApiDivisions, generateOpenApiFromDocsConfig, } from './generateOpenApiDivisions.js';
+export { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
+export { generateOpenApiFromDocsConfig } from './generateOpenApiFromDocsConfig.js';

package/dist/prebuild/update/index.d.ts

@@ -1,5 +1,16 @@
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
 import type { OpenApiFile } from '@mintlify/models';
-export declare const update: (contentDirectoryPath: string, staticFilenames: string[], openApiFiles: OpenApiFile[], contentFilenames: string[], snippets: string[], snippetV2Filenames: string[], docsConfigPath?: string | null) => Promise<{
+type UpdateArgs = {
+    contentDirectoryPath: string;
+    staticFilenames: string[];
+    openApiFiles: OpenApiFile[];
+    asyncApiFiles: AsyncAPIFile[];
+    contentFilenames: string[];
+    snippets: string[];
+    snippetV2Filenames: string[];
+    docsConfigPath?: string | null;
+};
+export declare const update: ({ contentDirectoryPath, staticFilenames, openApiFiles, asyncApiFiles, contentFilenames, snippets, snippetV2Filenames, docsConfigPath, }: UpdateArgs) => Promise<{
     name: string;
     $schema: string;
     theme: "mint";

package/dist/prebuild/update/index.js

@@ -8,12 +8,12 @@ import { updateFavicons } from './updateFavicons.js';
 import { updateGeneratedDocsNav, updateGeneratedNav } from './updateGeneratedNav.js';
 import { writeFiles } from './write/writeFiles.js';
 import { writeOpenApiFiles } from './write/writeOpenApiFiles.js';
-export const update = async (contentDirectoryPath, staticFilenames, openApiFiles, contentFilenames, snippets, snippetV2Filenames, docsConfigPath) => {
+export const update = async ({ contentDirectoryPath, staticFilenames, openApiFiles, asyncApiFiles, contentFilenames, snippets, snippetV2Filenames, docsConfigPath, }) => {
     const mintConfigResult = await updateMintConfigFile(contentDirectoryPath, openApiFiles);
     // we used the original mint config without openapi pages injected
     // because we will do it in `updateDocsConfigFile`, this will avoid duplicated openapi pages
     const docsConfig = mintConfigResult != null ? upgradeToDocsConfig(mintConfigResult.originalMintConfig) : undefined;
-    const { docsConfig: newDocsConfig, pagesAcc, newOpenApiFiles, } = await updateDocsConfigFile(contentDirectoryPath, openApiFiles, docsConfigPath ? undefined : docsConfig);
+    const { docsConfig: newDocsConfig, pagesAcc, newOpenApiFiles, } = await updateDocsConfigFile(contentDirectoryPath, openApiFiles, asyncApiFiles, docsConfigPath ? undefined : docsConfig);
     const pagePromises = readPageContents(contentDirectoryPath, newOpenApiFiles, contentFilenames, pagesAcc);
     const snippetV2Promises = readSnippetsV2Contents(contentDirectoryPath, snippetV2Filenames);
     const [snippetV2Contents, { mdxFilesWithNoImports, filesWithImports }] = await Promise.all([