@mintlify/prebuild 1.0.425 → 1.0.427

package/dist/createPage/index.d.ts

@@ -1,5 +1,6 @@
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
 import { OpenApiFile, DecoratedNavigationPage } from '@mintlify/models';
-export declare const createPage: (pagePath: string, pageContent: string, contentDirectoryPath: string, openApiFiles: OpenApiFile[], suppressErrLog?: boolean) => Promise<{
+export declare const createPage: (pagePath: string, pageContent: string, contentDirectoryPath: string, openApiFiles: OpenApiFile[], asyncApiFiles: AsyncAPIFile[], suppressErrLog?: boolean) => Promise<{
     pageMetadata: DecoratedNavigationPage;
     pageContent: string;
     slug: string;

package/dist/createPage/index.js

@@ -1,11 +1,11 @@
 import { getDecoratedNavPageAndSlug } from '@mintlify/common';
 import { getLocationErrString } from '../errorMessages/getLocationErrString.js';
 import { preparseMdx } from './preparseMdx/index.js';
-export const createPage = async (pagePath, pageContent, contentDirectoryPath, openApiFiles, suppressErrLog = false) => {
+export const createPage = async (pagePath, pageContent, contentDirectoryPath, openApiFiles, asyncApiFiles, suppressErrLog = false) => {
     let pageMetadata;
     let slug;
     try {
-        const { pageMetadata: metadata, slug: pageSlug } = getDecoratedNavPageAndSlug(pagePath, pageContent, openApiFiles);
+        const { pageMetadata: metadata, slug: pageSlug } = getDecoratedNavPageAndSlug(pagePath, pageContent, openApiFiles, asyncApiFiles);
         pageMetadata = metadata;
         slug = pageSlug;
         pageContent = await preparseMdx(pageContent, contentDirectoryPath, pagePath, suppressErrLog);

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

@@ -0,0 +1,8 @@
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
+import { DecoratedNavigationPage } from '@mintlify/models';
+import { DocsConfig } from '@mintlify/validation';
+export declare const generateAsyncApiDivisions: (docsConfig: DocsConfig, asyncApiFiles: AsyncAPIFile[], targetDir?: string) => Promise<{
+    newDocsConfig: DocsConfig;
+    pagesAcc: Record<string, DecoratedNavigationPage>;
+    asyncApiFiles: AsyncAPIFile[];
+}>;

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

@@ -0,0 +1,16 @@
+import { getAsyncApiFilesFromConfig } from '../read/getAsyncApiFilesFromConfig.js';
+import { generateAsyncApiFromDocsConfig } from './generateAsyncApiFromDocsConfig.js';
+export const generateAsyncApiDivisions = async (docsConfig, asyncApiFiles, targetDir) => {
+    const asyncApiFilesFromDocsConfig = await getAsyncApiFilesFromConfig(docsConfig);
+    const pagesAcc = {};
+    const { newNav, newAsyncApiFiles } = await generateAsyncApiFromDocsConfig(docsConfig.navigation, asyncApiFiles, pagesAcc, {
+        overwrite: true,
+        writeFiles: true,
+        targetDir,
+    });
+    return {
+        newDocsConfig: { ...docsConfig, navigation: newNav },
+        pagesAcc,
+        asyncApiFiles: [...asyncApiFiles, ...asyncApiFilesFromDocsConfig, ...newAsyncApiFiles],
+    };
+};

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

@@ -0,0 +1,11 @@
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
+import type { DecoratedNavigationPage } from '@mintlify/models';
+import { NavigationConfig } from '@mintlify/validation';
+export declare const generateAsyncApiFromDocsConfig: (navigation: NavigationConfig, asyncApiFiles: AsyncAPIFile[], pagesAcc: Record<string, DecoratedNavigationPage>, opts: {
+    overwrite?: boolean;
+    writeFiles: boolean;
+    targetDir?: string;
+}) => Promise<{
+    newNav: NavigationConfig;
+    newAsyncApiFiles: AsyncAPIFile[];
+}>;

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

@@ -0,0 +1,136 @@
+import { optionallyAddLeadingSlash } from '@mintlify/common';
+import { getAsyncApiDocumentFromUrl } from '@mintlify/common/asyncapi';
+import { generateAsyncApiPagesForDocsConfig } from '@mintlify/scraping';
+import { divisions } from '@mintlify/validation';
+import * as path from 'path';
+const DEFAULT_OUTPUT_DIR = 'api-reference';
+export const generateAsyncApiFromDocsConfig = async (navigation, asyncApiFiles, pagesAcc, opts) => {
+    const { overwrite, writeFiles, targetDir } = opts;
+    const newAsyncApiFiles = [];
+    async function processAsyncApiInNav(nav) {
+        let outputDir = DEFAULT_OUTPUT_DIR;
+        let asyncApis = [];
+        if ('asyncapi' in nav) {
+            if (typeof nav.asyncapi === 'string') {
+                asyncApis = [nav.asyncapi];
+            }
+            else if (Array.isArray(nav.asyncapi)) {
+                asyncApis = nav.asyncapi;
+            }
+            else if (typeof nav.asyncapi === 'object' && 'source' in nav.asyncapi) {
+                asyncApis = [nav.asyncapi.source];
+                outputDir = nav.asyncapi.directory ?? DEFAULT_OUTPUT_DIR;
+            }
+        }
+        if (asyncApis.length > 0) {
+            const processedAsyncApiFiles = [];
+            for (const asyncApi of asyncApis) {
+                let asyncApiFile = undefined;
+                if (asyncApi.startsWith('https://')) {
+                    asyncApiFile = await createAsyncApiFile(asyncApi);
+                    newAsyncApiFiles.push(asyncApiFile);
+                }
+                else {
+                    asyncApiFile = asyncApiFiles.find((file) => file.originalFileLocation === optionallyAddLeadingSlash(asyncApi));
+                }
+                if (!asyncApiFile) {
+                    if (asyncApi === asyncApis[0] &&
+                        asyncApiFiles.length > 0 &&
+                        !asyncApiFiles[0]?.spec.channels().length) {
+                        throw new Error('No channels defined');
+                    }
+                    throw new Error(`AsyncAPI file ${asyncApi} defined in ${getDivisionNav(nav)
+                        ?.division} in your docs.json does not exist`);
+                }
+                processedAsyncApiFiles.push(asyncApiFile);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let allGeneratedNav = [];
+            for (const asyncApiFile of processedAsyncApiFiles) {
+                const { pagesAcc: pagesAccFromGeneratedAsyncApiPages, nav: navFromGeneratedAsyncApiPages } = await generateAsyncApiPagesForDocsConfig(asyncApiFile.spec, {
+                    asyncApiFilePath: asyncApiFile.originalFileLocation,
+                    writeFiles,
+                    outDir: outputDir,
+                    outDirBasePath: path.join(targetDir ?? '', 'src', '_props'),
+                    overwrite,
+                });
+                Object.entries(pagesAccFromGeneratedAsyncApiPages).forEach(([key, value]) => {
+                    pagesAcc[key] = value;
+                });
+                allGeneratedNav = [...allGeneratedNav, ...navFromGeneratedAsyncApiPages];
+            }
+            const divisionNav = getDivisionNav(nav);
+            if (divisionNav?.division) {
+                return {
+                    [divisionNav.division]: divisionNav.name,
+                    ...divisionNav.nav,
+                    ...(divisionNav.division === 'group'
+                        ? {
+                            pages: 'pages' in nav ? [...nav.pages, ...allGeneratedNav] : allGeneratedNav,
+                        }
+                        : {
+                            groups: 'groups' in nav ? [...nav.groups, ...allGeneratedNav] : allGeneratedNav,
+                        }),
+                };
+            }
+        }
+        return null;
+    }
+    async function processNav(nav) {
+        const processedNav = await processAsyncApiInNav(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,
+        newAsyncApiFiles,
+    };
+};
+function getDivisionNav(nav) {
+    if ('asyncapi' in nav) {
+        const { asyncapi: _, ...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 createAsyncApiFile(url) {
+    try {
+        const document = await getAsyncApiDocumentFromUrl(url);
+        return {
+            filename: url,
+            spec: document,
+            originalFileLocation: url,
+        };
+    }
+    catch (err) {
+        console.error(err);
+        throw err;
+    }
+}

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

@@ -1,10 +1,11 @@
 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[], _asyncApiFiles: AsyncAPIFile[], docsConfig?: DocsConfig): Promise<{
+export declare function updateDocsConfigFile(contentDirectoryPath: string, openApiFiles: OpenApiFile[], asyncApiFiles: AsyncAPIFile[], docsConfig?: DocsConfig): Promise<{
     docsConfig: DocsConfig;
     pagesAcc: Record<string, DecoratedNavigationPage>;
     newOpenApiFiles: OpenApiFile[];
+    newAsyncApiFiles: AsyncAPIFile[];
 }>;
 export { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
 export { generateOpenApiFromDocsConfig } from './generateOpenApiFromDocsConfig.js';

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

@@ -1,7 +1,8 @@
 import { getConfigPath } from '../../../utils.js';
 import { DocsConfigUpdater } from '../ConfigUpdater.js';
+import { generateAsyncApiDivisions } from './generateAsyncApiDivisions.js';
 import { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
-export async function updateDocsConfigFile(contentDirectoryPath, openApiFiles, _asyncApiFiles, 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.');
@@ -12,9 +13,11 @@ export async function updateDocsConfigFile(contentDirectoryPath, openApiFiles, _
     if (docsConfig == null) {
         throw Error('Must be run in a directory where a docs.json file exists.');
     }
-    const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = await generateOpenApiDivisions(docsConfig, openApiFiles);
+    const { newDocsConfig: docsConfigWithOpenApiPages, pagesAcc: pagesAccWithOpenApiPages, openApiFiles: newOpenApiFiles, } = await generateOpenApiDivisions(docsConfig, openApiFiles);
+    const { newDocsConfig, pagesAcc: pagesAccWithAsyncApiPages, asyncApiFiles: newAsyncApiFiles, } = await generateAsyncApiDivisions(docsConfigWithOpenApiPages, asyncApiFiles);
+    const pagesAcc = { ...pagesAccWithOpenApiPages, ...pagesAccWithAsyncApiPages };
     await DocsConfigUpdater.writeConfigFile(newDocsConfig);
-    return { docsConfig: newDocsConfig, pagesAcc, newOpenApiFiles };
+    return { docsConfig: newDocsConfig, pagesAcc, newOpenApiFiles, newAsyncApiFiles };
 }
 export { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
 export { generateOpenApiFromDocsConfig } from './generateOpenApiFromDocsConfig.js';

package/dist/prebuild/update/index.js

@@ -6,6 +6,7 @@ import { readPageContents, readSnippetsV2Contents } from './read/readContent.js'
 import { resolveImportsAndWriteFiles } from './resolveImportsAndWriteFiles.js';
 import { updateFavicons } from './updateFavicons.js';
 import { updateGeneratedDocsNav, updateGeneratedNav } from './updateGeneratedNav.js';
+import { writeAsyncApiFiles } from './write/writeAsyncApiFiles.js';
 import { writeFiles } from './write/writeFiles.js';
 import { writeOpenApiFiles } from './write/writeOpenApiFiles.js';
 export const update = async ({ contentDirectoryPath, staticFilenames, openApiFiles, asyncApiFiles, contentFilenames, snippets, snippetV2Filenames, docsConfigPath, }) => {
@@ -13,16 +14,29 @@ export const update = async ({ contentDirectoryPath, staticFilenames, openApiFil
     // 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, asyncApiFiles, docsConfigPath ? undefined : docsConfig);
-    const pagePromises = readPageContents(contentDirectoryPath, newOpenApiFiles, contentFilenames, pagesAcc);
+    const { docsConfig: newDocsConfig, pagesAcc, newOpenApiFiles, newAsyncApiFiles, } = await updateDocsConfigFile(contentDirectoryPath, openApiFiles, asyncApiFiles, docsConfigPath ? undefined : docsConfig);
+    const pagePromises = readPageContents({
+        contentDirectoryPath,
+        openApiFiles: newOpenApiFiles,
+        asyncApiFiles: newAsyncApiFiles,
+        contentFilenames,
+        pagesAcc,
+    });
     const snippetV2Promises = readSnippetsV2Contents(contentDirectoryPath, snippetV2Filenames);
     const [snippetV2Contents, { mdxFilesWithNoImports, filesWithImports }] = await Promise.all([
         snippetV2Promises,
         pagePromises,
     ]);
     await Promise.all([
-        resolveImportsAndWriteFiles(openApiFiles, pagesAcc, snippetV2Contents, filesWithImports),
+        resolveImportsAndWriteFiles({
+            openApiFiles: newOpenApiFiles,
+            asyncApiFiles: newAsyncApiFiles,
+            pagesAcc,
+            snippetsV2: snippetV2Contents,
+            filesWithImports,
+        }),
         writeOpenApiFiles(newOpenApiFiles),
+        writeAsyncApiFiles(newAsyncApiFiles),
         updateFavicons(newDocsConfig, contentDirectoryPath),
         ...writeMdxFilesWithNoImports(mdxFilesWithNoImports),
         ...writeFiles(contentDirectoryPath, 'public', [...staticFilenames, ...snippets]),

package/dist/prebuild/update/read/getAsyncApiFilesFromConfig.d.ts

@@ -0,0 +1,3 @@
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
+import { DocsConfig } from '@mintlify/validation';
+export declare const getAsyncApiFilesFromConfig: (config: DocsConfig) => Promise<AsyncAPIFile[]>;

package/dist/prebuild/update/read/getAsyncApiFilesFromConfig.js

@@ -0,0 +1,30 @@
+import { getAsyncApiDocumentFromUrl } from '@mintlify/common/asyncapi';
+export const getAsyncApiFilesFromConfig = async (config) => {
+    const asyncApiConfig = config.api?.asyncapi;
+    const asyncApiFiles = [];
+    async function addAsyncApiFileFromUrl(url) {
+        try {
+            const document = await getAsyncApiDocumentFromUrl(url);
+            asyncApiFiles.push({
+                filename: url,
+                spec: document,
+                originalFileLocation: url,
+            });
+        }
+        catch (err) {
+            console.error(err);
+            throw err;
+        }
+    }
+    if (asyncApiConfig) {
+        if (typeof asyncApiConfig === 'string' && asyncApiConfig.startsWith('https://')) {
+            await addAsyncApiFileFromUrl(asyncApiConfig);
+        }
+        else if (typeof asyncApiConfig === 'object' &&
+            'source' in asyncApiConfig &&
+            asyncApiConfig.source.startsWith('https')) {
+            await addAsyncApiFileFromUrl(asyncApiConfig.source);
+        }
+    }
+    return asyncApiFiles;
+};

package/dist/prebuild/update/read/readContent.d.ts

@@ -1,6 +1,14 @@
 import type { FileWithImports } from '@mintlify/common';
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
 import type { OpenApiFile, DecoratedNavigationPage } from '@mintlify/models';
-export declare const readPageContents: (contentDirectoryPath: string, openApiFiles: OpenApiFile[], contentFilenames: string[], pagesAcc: Record<string, DecoratedNavigationPage>) => Promise<{
+type ReadPageContentsArgs = {
+    contentDirectoryPath: string;
+    openApiFiles: OpenApiFile[];
+    asyncApiFiles: AsyncAPIFile[];
+    contentFilenames: string[];
+    pagesAcc: Record<string, DecoratedNavigationPage>;
+};
+export declare const readPageContents: ({ contentDirectoryPath, openApiFiles, asyncApiFiles, contentFilenames, pagesAcc, }: ReadPageContentsArgs) => Promise<{
     mdxFilesWithNoImports: {
         targetPath: string;
         fileContent: string;
@@ -12,3 +20,4 @@ export declare const readSnippetsV2Contents: (contentDirectoryPath: string, snip
     filename: string;
     content: string;
 }[]>;
+export {};

package/dist/prebuild/update/read/readContent.js

@@ -3,7 +3,7 @@ import { promises as _promises } from 'fs';
 import { join } from 'path';
 import { preparseMdx } from '../../../createPage/preparseMdx/index.js';
 const { readFile } = _promises;
-export const readPageContents = async (contentDirectoryPath, openApiFiles, contentFilenames, pagesAcc) => {
+export const readPageContents = async ({ contentDirectoryPath, openApiFiles, asyncApiFiles, contentFilenames, pagesAcc, }) => {
     const filesWithImports = [];
     const pagePromises = contentFilenames.map(async (filename) => {
         const sourcePath = join(contentDirectoryPath, filename);
@@ -20,7 +20,7 @@ export const readPageContents = async (contentDirectoryPath, openApiFiles, conte
                 });
                 return;
             }
-            const { slug, pageMetadata } = getDecoratedNavPageAndSlug(filename, contentStr, openApiFiles);
+            const { slug, pageMetadata } = getDecoratedNavPageAndSlug(filename, contentStr, openApiFiles, asyncApiFiles);
             pagesAcc[slug] = pageMetadata;
             return { targetPath, fileContent };
         }

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

@@ -1,3 +1,12 @@
 import type { FileType, FileWithImports } from '@mintlify/common';
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
 import type { OpenApiFile, DecoratedNavigationPage } from '@mintlify/models';
-export declare const resolveImportsAndWriteFiles: (openApiFiles: OpenApiFile[], pagesAcc: Record<string, DecoratedNavigationPage>, snippetsV2: FileType[], filesWithImports: FileWithImports[]) => Promise<void>;
+type ResolveImportsAndWriteFilesArgs = {
+    openApiFiles: OpenApiFile[];
+    asyncApiFiles: AsyncAPIFile[];
+    pagesAcc: Record<string, DecoratedNavigationPage>;
+    snippetsV2: FileType[];
+    filesWithImports: FileWithImports[];
+};
+export declare const resolveImportsAndWriteFiles: ({ openApiFiles, asyncApiFiles, pagesAcc, snippetsV2, filesWithImports, }: ResolveImportsAndWriteFilesArgs) => Promise<void>;
+export {};

package/dist/prebuild/update/resolveImportsAndWriteFiles.js

@@ -1,10 +1,16 @@
 import { resolveAllImports, hasImports, findAndRemoveImports, getDecoratedNavPageAndSlug, topologicalSort, } from '@mintlify/common';
 import { outputFile } from 'fs-extra';
 import { join } from 'path';
-export const resolveImportsAndWriteFiles = async (openApiFiles, pagesAcc, snippetsV2, filesWithImports) => {
+export const resolveImportsAndWriteFiles = async ({ openApiFiles, asyncApiFiles, pagesAcc, snippetsV2, filesWithImports, }) => {
     const snippetsWithResolvedImports = await resolveImportsInSnippets(snippetsV2);
     const writeSnippetsWithImportsPromises = await writeSnippets(snippetsWithResolvedImports);
-    const pagesWithResolvedImports = await resolveImportsInPages(openApiFiles, snippetsWithResolvedImports, filesWithImports, pagesAcc);
+    const pagesWithResolvedImports = await resolveImportsInPages({
+        openApiFiles,
+        asyncApiFiles,
+        snippetsWithResolvedImports,
+        filesWithImports,
+        pagesAcc,
+    });
     const writePagesPromise = writePages(pagesWithResolvedImports);
     await Promise.all([...writeSnippetsWithImportsPromises, ...writePagesPromise]);
 };
@@ -40,13 +46,13 @@ const writeSnippets = async (snippetsWithImports) => snippetsWithImports.map(asy
         flag: 'w',
     });
 });
-const resolveImportsInPages = async (openApiFiles, snippetsWithResolvedImports, filesWithImports, pagesAcc) => {
+const resolveImportsInPages = async ({ openApiFiles, asyncApiFiles, snippetsWithResolvedImports, filesWithImports, pagesAcc, }) => {
     const filesWithResolvedImportsPromises = filesWithImports.map(async (fileWithImports) => {
         const content = await resolveAllImports({
             snippets: snippetsWithResolvedImports,
             fileWithImports,
         });
-        const { slug, pageMetadata } = getDecoratedNavPageAndSlug(fileWithImports.filename, content, openApiFiles);
+        const { slug, pageMetadata } = getDecoratedNavPageAndSlug(fileWithImports.filename, content, openApiFiles, asyncApiFiles);
         pagesAcc[slug] = pageMetadata;
         const targetPath = join('src', '_props', fileWithImports.filename);
         return {

package/dist/prebuild/update/write/writeAsyncApiFiles.d.ts

@@ -0,0 +1,2 @@
+import { AsyncAPIFile } from '@mintlify/common/asyncapi';
+export declare const writeAsyncApiFiles: (asyncApiFiles: AsyncAPIFile[]) => Promise<void>;

package/dist/prebuild/update/write/writeAsyncApiFiles.js

@@ -0,0 +1,8 @@
+import fse from 'fs-extra';
+export const writeAsyncApiFiles = async (asyncApiFiles) => {
+    const asyncApiTargetPath = 'src/_props/asyncApiFiles.json';
+    await fse.remove(asyncApiTargetPath);
+    await fse.outputFile(asyncApiTargetPath, JSON.stringify(asyncApiFiles), {
+        flag: 'w',
+    });
+};