@mintlify/prebuild 1.0.316 → 1.0.318

package/dist/prebuild/update/ConfigUpdater.js

@@ -0,0 +1,93 @@
+import { validateMintConfig, validateDocsConfig, formatIssue, } from '@mintlify/validation';
+import Chalk from 'chalk';
+import { promises as _promises } from 'fs';
+import fse from 'fs-extra';
+import { join } from 'path';
+const { readFile } = _promises;
+export class ConfigUpdater {
+    static getInstance(type) {
+        if (!ConfigUpdater.instances.has(type)) {
+            ConfigUpdater.instances.set(type, new ConfigUpdater(type));
+        }
+        return ConfigUpdater.instances.get(type);
+    }
+    constructor(type) {
+        this.validateMintConfigJson = async (configContents) => {
+            if (this.type !== 'mint') {
+                throw Error('validateMintConfigJson is only available for mint.json');
+            }
+            const configObj = this.parseConfigJson(configContents);
+            const validationResults = validateMintConfig(configObj);
+            if (!validationResults.success) {
+                console.error(Chalk.red(`🚨 Invalid ${this.type}.json:`));
+                validationResults.error.issues.forEach((issue) => console.error(Chalk.red(formatIssue(issue))));
+                throw Error();
+            }
+            if (validationResults.warnings.length > 0) {
+                if (validationResults.warnings.length > 0) {
+                    console.warn(Chalk.yellow(`⚠️ Warnings found in ${this.type}.json:`));
+                    validationResults.warnings.forEach((issue) => console.warn(Chalk.yellow(formatIssue(issue))));
+                }
+            }
+            return validationResults;
+        };
+        this.validateDocsConfigJson = async (configContents) => {
+            if (this.type !== 'docs') {
+                throw Error('validateDocsConfigJson is only available for docs.json');
+            }
+            const configObj = this.parseConfigJson(configContents);
+            const validationResults = validateDocsConfig(configObj);
+            if (!validationResults.success) {
+                console.error(Chalk.red(`🚨 Invalid ${this.type}.json:`));
+                validationResults.error.issues.forEach((issue) => console.error(Chalk.red(formatIssue(issue))));
+                throw Error();
+            }
+            return validationResults;
+        };
+        this.readConfigFile = async (configPath) => {
+            let configContents;
+            try {
+                configContents = await readFile(configPath, 'utf-8');
+            }
+            catch (err) {
+                throw Error(`Unable to read ${this.type}.json: ${err}`);
+            }
+            return configContents;
+        };
+        this.writeConfigFile = async (config, targetDir) => {
+            try {
+                await fse.outputFile(join(targetDir ?? '', `src/_props/${this.type}.json`), JSON.stringify(config, null, 2), {
+                    flag: 'w',
+                });
+            }
+            catch (err) {
+                throw Error(`Unable to write ${this.type}.json: ${err}`);
+            }
+        };
+        this.parseConfigJson = (configContents) => {
+            let configObj;
+            try {
+                configObj = JSON.parse(configContents);
+            }
+            catch (e) {
+                if (typeof e === 'object' && e != null) {
+                    if ('name' in e && e.name === 'SyntaxError') {
+                        console.error(`🚨 ${Chalk.red(`${this.type}.json has invalid JSON. You are likely missing a comma or a bracket. You can paste your ${this.type}.json file into https://jsonlint.com/ to get a more specific error message.`)}`);
+                    }
+                    else if ('message' in e) {
+                        console.error(`🚨 ${Chalk.red(e.message)}`);
+                    }
+                }
+                throw Error();
+            }
+            return configObj;
+        };
+        this.type = type;
+    }
+    getConfigType() {
+        return this.type;
+    }
+}
+ConfigUpdater.instances = new Map();
+export const MintConfigUpdater = ConfigUpdater.getInstance('mint');
+export const DocsConfigUpdater = ConfigUpdater.getInstance('docs');

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

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

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

@@ -0,0 +1,129 @@
+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';
+export const generateOpenApiDivisions = async (docsConfig, openApiFiles, targetDir) => {
+    const openapiFilesFromDocsConfig = await getOpenApiFilesFromConfig('docs', docsConfig);
+    openApiFiles.push(...openapiFilesFromDocsConfig);
+    const pagesAcc = {};
+    const { newNav, newOpenApiFiles } = await generateOpenApiFromDocsConfig(docsConfig.navigation, openApiFiles, pagesAcc, {
+        overwrite: true,
+        writeFiles: true,
+        targetDir,
+    });
+    return {
+        newDocsConfig: { ...docsConfig, navigation: newNav },
+        pagesAcc,
+        openApiFiles: [...openApiFiles, ...newOpenApiFiles],
+    };
+};
+export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pagesAcc, opts) => {
+    const { overwrite, writeFiles, targetDir } = opts;
+    const newOpenApiFiles = [];
+    async function processOpenApiInNav(nav // we will need one of the divisions to be able to get the openapi param (type safety)
+    ) {
+        let outputDir = DEFAULT_OUTPUT_DIR;
+        let openapi;
+        if ('openapi' in nav) {
+            if (typeof nav.openapi === 'string') {
+                openapi = nav.openapi;
+            }
+            else if (typeof nav.openapi === 'object' && 'source' in nav.openapi) {
+                openapi = nav.openapi.source;
+                outputDir = nav.openapi.directory;
+            }
+        }
+        if (openapi) {
+            let openApiFile = undefined;
+            if (openapi.startsWith('https')) {
+                openApiFile = await createOpenApiFile(openapi, getDivisionNav(nav)?.division ?? 'unknown');
+                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,
+                    groups: navFromGeneratedOpenApiPages,
+                    ...divisionNav.nav,
+                };
+            }
+        }
+        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}-1`,
+            spec: document,
+        };
+    }
+    catch (err) {
+        console.error(err);
+        throw err;
+    }
+}