@mintlify/prebuild 1.0.1186 → 1.0.1188

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

@@ -6,6 +6,7 @@ export declare const generateAsyncApiFromDocsConfig: (navigation: NavigationConf
     writeFiles: boolean;
     targetDir?: string;
     localSchema?: boolean;
+    writeFile?: (filename: string, content: string) => void | Promise<void>;
 }) => Promise<{
     newNav: NavigationConfig;
     newAsyncApiFiles: AsyncAPIFile[];

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

@@ -4,7 +4,7 @@ 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, localSchema } = opts;
+    const { overwrite, writeFiles, targetDir, localSchema, writeFile } = opts;
     const newAsyncApiFiles = [];
     async function processAsyncApiInNav(nav) {
         let outputDir = DEFAULT_OUTPUT_DIR;
@@ -52,6 +52,7 @@ export const generateAsyncApiFromDocsConfig = async (navigation, asyncApiFiles,
                     outDirBasePath: path.join(targetDir ?? '', 'src', '_props'),
                     overwrite,
                     localSchema,
+                    writeFile,
                 });
                 Object.entries(pagesAccFromGeneratedAsyncApiPages).forEach(([key, value]) => {
                     pagesAcc[key] = value;

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

@@ -0,0 +1,27 @@
+import type { DecoratedNavigationPage, GraphqlReference, GraphqlTarget } from '@mintlify/models';
+import type { DocsConfig } from '@mintlify/validation';
+export type GeneratedGraphqlPage = {
+    slug: string;
+    title: string;
+    description?: string;
+    deprecated?: boolean;
+    tag: string;
+    target: GraphqlTarget;
+};
+export type GenerateGraphqlDivisionsResult = {
+    navigation: DocsConfig['navigation'];
+    newDocsConfig: DocsConfig;
+    pagesAcc: Record<string, DecoratedNavigationPage>;
+    generatedPages: GeneratedGraphqlPage[];
+    generatedRoutes: string[];
+    parsedReferences: Record<string, GraphqlReference>;
+};
+export type GraphqlSourceLoader = (source: string) => Promise<string>;
+export declare const getGraphqlRouteKey: (route: string) => string;
+/** Transform GraphQL navigation without reading or writing the filesystem. */
+export declare function generateGraphqlDivisionsFromDocsConfig(docsConfig: DocsConfig, loadSource: GraphqlSourceLoader): Promise<GenerateGraphqlDivisionsResult>;
+export declare function generateGraphqlDivisions(docsConfig: DocsConfig, contentDirectoryPath: string, targetDir?: string): Promise<GenerateGraphqlDivisionsResult>;
+export declare function loadGraphqlSdlSource(source: string, contentDirectoryPath: string): Promise<string>;
+export declare const isRemoteGraphqlSource: (source: string) => boolean;
+export declare function writeGraphqlArtifacts(result: GenerateGraphqlDivisionsResult, targetDir?: string): Promise<void>;
+export { loadRemoteGraphqlSdl } from './loadRemoteGraphqlSdl.js';

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

@@ -0,0 +1,259 @@
+import { parseGraphqlSdl } from '@mintlify/scraping';
+import fse from 'fs-extra';
+import { open } from 'node:fs/promises';
+import path from 'node:path';
+import { getGeneratedRouteKey } from './generatedRouteCollisions.js';
+import { loadRemoteGraphqlSdl, MAX_GRAPHQL_SCHEMA_BYTES } from './loadRemoteGraphqlSdl.js';
+const DEFAULT_OUTPUT_DIR = 'graphql-reference';
+const byName = (left, right) => left.name.localeCompare(right.name);
+export const getGraphqlRouteKey = getGeneratedRouteKey;
+function graphqlConfig(config) {
+    return typeof config === 'string'
+        ? { source: config, directory: DEFAULT_OUTPUT_DIR }
+        : { source: config.source, directory: config.directory ?? DEFAULT_OUTPUT_DIR };
+}
+function makePage(source, directory, kind, entry) {
+    const section = kind === 'query' ? 'queries' : kind === 'mutation' ? 'mutations' : 'types';
+    return {
+        slug: path.posix.join(directory, section, entry.name),
+        title: entry.name,
+        ...('description' in entry && entry.description ? { description: entry.description } : {}),
+        ...(kind !== 'type' && 'deprecationReason' in entry && entry.deprecationReason != null
+            ? { deprecated: true }
+            : {}),
+        tag: kind === 'type' && 'kind' in entry ? entry.kind.toUpperCase() : kind.toUpperCase(),
+        target: { source, kind, name: entry.name },
+    };
+}
+function generatePages(reference, source, directory) {
+    const roots = new Set([reference.queryType, reference.mutationType, reference.subscriptionType].filter((name) => name !== undefined));
+    const typeByName = new Map(reference.types.map((type) => [type.name, type]));
+    const queryType = reference.queryType ? typeByName.get(reference.queryType) : undefined;
+    const mutationType = reference.mutationType ? typeByName.get(reference.mutationType) : undefined;
+    const queryFields = reference.queryType
+        ? queryType?.kind === 'object'
+            ? queryType.fields
+            : []
+        : [];
+    const mutationFields = reference.mutationType
+        ? mutationType?.kind === 'object'
+            ? mutationType.fields
+            : []
+        : [];
+    return {
+        queries: queryFields
+            .slice()
+            .sort(byName)
+            .map((field) => makePage(source, directory, 'query', field)),
+        mutations: mutationFields
+            .slice()
+            .sort(byName)
+            .map((field) => makePage(source, directory, 'mutation', field)),
+        types: reference.types
+            .filter((type) => !roots.has(type.name) &&
+            (type.kind === 'object' ||
+                type.kind === 'interface' ||
+                type.kind === 'union' ||
+                type.kind === 'enum'))
+            .slice()
+            .sort(byName)
+            .map((type) => makePage(source, directory, 'type', type)),
+    };
+}
+function mdxStub(page) {
+    const fields = [
+        `title: ${JSON.stringify(page.title)}`,
+        ...(page.description ? [`description: ${JSON.stringify(page.description)}`] : []),
+        ...(page.deprecated ? ['deprecated: true'] : []),
+        `tag: ${JSON.stringify(page.tag)}`,
+        `graphql: ${JSON.stringify(page.target)}`,
+    ];
+    return `---\n${fields.join('\n')}\n---\n`;
+}
+/** Transform GraphQL navigation without reading or writing the filesystem. */
+export async function generateGraphqlDivisionsFromDocsConfig(docsConfig, loadSource) {
+    const references = new Map();
+    const parsedReferences = new Map();
+    const pagesByRouteKey = new Map();
+    async function load(source) {
+        let pending = references.get(source);
+        if (!pending) {
+            pending = loadSource(source).then((sdl) => {
+                const reference = parseGraphqlSdl(sdl);
+                parsedReferences.set(source, reference);
+                return reference;
+            });
+            references.set(source, pending);
+        }
+        return pending;
+    }
+    async function processNode(value) {
+        if (Array.isArray(value))
+            return Promise.all(value.map(processNode));
+        if (typeof value !== 'object' || value === null)
+            return value;
+        const node = value;
+        if ('tab' in node && 'graphql' in node) {
+            const { graphql, ...tab } = node;
+            const { source, directory } = graphqlConfig(graphql);
+            const generated = generatePages(await load(source), source, directory);
+            const groups = [
+                { group: 'Queries', pages: generated.queries.map(({ slug }) => slug) },
+                { group: 'Mutations', pages: generated.mutations.map(({ slug }) => slug) },
+                { group: 'Types', pages: generated.types.map(({ slug }) => slug) },
+            ].filter(({ pages }) => pages.length > 0);
+            for (const page of [...generated.queries, ...generated.mutations, ...generated.types]) {
+                const routeKey = getGraphqlRouteKey(page.slug);
+                const existingPage = pagesByRouteKey.get(routeKey);
+                if (existingPage &&
+                    (existingPage.slug !== page.slug ||
+                        existingPage.target.source !== page.target.source ||
+                        existingPage.target.kind !== page.target.kind ||
+                        existingPage.target.name !== page.target.name)) {
+                    throw new Error(`Multiple GraphQL references generate colliding routes "${existingPage.slug}" and "${page.slug}"`);
+                }
+                pagesByRouteKey.set(routeKey, page);
+            }
+            return { ...tab, groups: [...(tab.groups ?? []), ...groups] };
+        }
+        return Object.fromEntries(await Promise.all(Object.entries(node).map(async ([key, entry]) => [key, await processNode(entry)])));
+    }
+    const navigation = await processNode(docsConfig.navigation);
+    const generatedPages = [...pagesByRouteKey.values()].sort((left, right) => getGeneratedRouteKey(left.slug).localeCompare(getGeneratedRouteKey(right.slug)) ||
+        left.slug.localeCompare(right.slug));
+    const pagesAcc = Object.fromEntries(generatedPages.map((page) => [
+        page.slug,
+        {
+            href: `/${page.slug}`,
+            title: page.title,
+            ...(page.description ? { description: page.description } : {}),
+            ...(page.deprecated ? { deprecated: true } : {}),
+            tag: page.tag,
+            graphql: page.target,
+        },
+    ]));
+    return {
+        navigation: navigation,
+        newDocsConfig: { ...docsConfig, navigation: navigation },
+        pagesAcc,
+        generatedPages,
+        generatedRoutes: generatedPages.map(({ slug }) => slug),
+        parsedReferences: Object.fromEntries([...parsedReferences].sort(([left], [right]) => left.localeCompare(right))),
+    };
+}
+export async function generateGraphqlDivisions(docsConfig, contentDirectoryPath, targetDir) {
+    const result = await generateGraphqlDivisionsFromDocsConfig(docsConfig, (source) => loadGraphqlSdlSource(source, contentDirectoryPath));
+    await writeGraphqlArtifacts(result, targetDir);
+    return result;
+}
+export async function loadGraphqlSdlSource(source, contentDirectoryPath) {
+    if (path.isAbsolute(source) || path.win32.isAbsolute(source)) {
+        throw new Error(`Unable to load GraphQL schema ${source}: path must be relative`);
+    }
+    let sourceUrl;
+    try {
+        sourceUrl = new URL(source);
+    }
+    catch { }
+    if (sourceUrl) {
+        if (sourceUrl.protocol === 'https:')
+            return loadRemoteGraphqlSdl(sourceUrl.href);
+        throw new Error(`Unable to load GraphQL schema ${source}: URL must use HTTPS`);
+    }
+    try {
+        const contentRoot = await fse.realpath(contentDirectoryPath);
+        const candidatePath = path.resolve(contentRoot, source);
+        const relativePath = path.relative(contentRoot, candidatePath);
+        if (relativePath === '..' ||
+            relativePath.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relativePath)) {
+            throw new Error('path escapes the content directory');
+        }
+        const realSourcePath = await fse.realpath(candidatePath);
+        const realRelativePath = path.relative(contentRoot, realSourcePath);
+        if (realRelativePath === '..' ||
+            realRelativePath.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(realRelativePath)) {
+            throw new Error('path resolves outside the content directory');
+        }
+        const schemaFile = await open(realSourcePath, 'r');
+        try {
+            const schemaStats = await schemaFile.stat();
+            if (schemaStats.size > MAX_GRAPHQL_SCHEMA_BYTES) {
+                throw new Error(`schema exceeds the ${MAX_GRAPHQL_SCHEMA_BYTES} byte limit`);
+            }
+            const decoder = new TextDecoder();
+            let schema = '';
+            let byteLength = 0;
+            for await (const chunk of schemaFile.createReadStream({ autoClose: false })) {
+                byteLength += chunk.length;
+                if (byteLength > MAX_GRAPHQL_SCHEMA_BYTES) {
+                    throw new Error(`schema exceeds the ${MAX_GRAPHQL_SCHEMA_BYTES} byte limit`);
+                }
+                schema += decoder.decode(chunk, { stream: true });
+            }
+            return schema + decoder.decode();
+        }
+        finally {
+            await schemaFile.close();
+        }
+    }
+    catch (error) {
+        const detail = error instanceof Error ? `: ${error.message}` : '';
+        throw new Error(`Unable to load GraphQL schema ${source}${detail}`);
+    }
+}
+export const isRemoteGraphqlSource = (source) => {
+    try {
+        return new URL(source).protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+};
+function getContainedGraphqlPagePath(targetDir, page) {
+    const propsDirectory = path.resolve(targetDir ?? '', 'src', '_props');
+    const pagePath = path.resolve(propsDirectory, `${page}.mdx`);
+    const relativePath = path.relative(propsDirectory, pagePath);
+    if (relativePath.startsWith(`..${path.sep}`) ||
+        relativePath === '..' ||
+        path.isAbsolute(relativePath)) {
+        return undefined;
+    }
+    return pagePath;
+}
+export async function writeGraphqlArtifacts(result, targetDir) {
+    const propsDirectory = path.resolve(targetDir ?? '', 'src', '_props');
+    const artifactPath = path.join(propsDirectory, 'graphql-data.json');
+    try {
+        const previousArtifacts = JSON.parse(await fse.readFile(artifactPath, 'utf8'));
+        if (previousArtifacts.pages != null &&
+            typeof previousArtifacts.pages === 'object' &&
+            !Array.isArray(previousArtifacts.pages)) {
+            await Promise.all(Object.keys(previousArtifacts.pages).flatMap((page) => {
+                const pagePath = getContainedGraphqlPagePath(targetDir, page);
+                return pagePath ? [fse.remove(pagePath)] : [];
+            }));
+        }
+    }
+    catch { }
+    await fse.remove(artifactPath);
+    if (Object.keys(result.parsedReferences).length === 0 && result.generatedRoutes.length === 0) {
+        return;
+    }
+    const artifacts = {
+        references: result.parsedReferences,
+        pages: Object.fromEntries(result.generatedPages.map((page) => {
+            const directory = path.posix.dirname(path.posix.dirname(page.slug));
+            const routes = Object.fromEntries(result.generatedPages
+                .filter((generatedPage) => generatedPage.target.source === page.target.source &&
+                generatedPage.target.kind === 'type' &&
+                path.posix.dirname(path.posix.dirname(generatedPage.slug)) === directory)
+                .map((generatedPage) => [generatedPage.target.name, `/${generatedPage.slug}`]));
+            return [page.slug, { target: page.target, routes }];
+        })),
+    };
+    await fse.outputFile(artifactPath, JSON.stringify(artifacts), { flag: 'w' });
+    await Promise.all(result.generatedPages.map((page) => fse.outputFile(path.join(targetDir ?? '', 'src', '_props', `${page.slug}.mdx`), mdxStub(page), { flag: 'w' })));
+}
+export { loadRemoteGraphqlSdl } from './loadRemoteGraphqlSdl.js';

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

@@ -1,8 +1,9 @@
 import type { OpenApiFile, DecoratedNavigationPage } from '@mintlify/models';
 import { DocsConfig } from '@mintlify/validation';
 import type { InvalidSpecFile } from '../../invalidSpecFiles.js';
-export declare const generateOpenApiDivisions: (docsConfig: DocsConfig, openApiFiles: OpenApiFile[], targetDir?: string, localSchema?: boolean, invalidSpecFiles?: InvalidSpecFile[]) => Promise<{
+export declare const generateOpenApiDivisions: (docsConfig: DocsConfig, openApiFiles: OpenApiFile[], targetDir?: string, localSchema?: boolean, invalidSpecFiles?: InvalidSpecFile[], graphqlPages?: Record<string, DecoratedNavigationPage>, deferWrites?: boolean) => Promise<{
     newDocsConfig: DocsConfig;
     pagesAcc: Record<string, DecoratedNavigationPage>;
     openApiFiles: OpenApiFile[];
+    flushWrites: () => Promise<void>;
 }>;

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

@@ -1,19 +1,39 @@
+import fse from 'fs-extra';
 import { getOpenApiFilesFromConfig } from '../read/getOpenApiFilesFromConfig.js';
+import { assertNoGeneratedRouteCollisions } from './generatedRouteCollisions.js';
 import { generateOpenApiFromDocsConfig } from './generateOpenApiFromDocsConfig.js';
-export const generateOpenApiDivisions = async (docsConfig, openApiFiles, targetDir, localSchema, invalidSpecFiles) => {
+export const generateOpenApiDivisions = async (docsConfig, openApiFiles, targetDir, localSchema, invalidSpecFiles, graphqlPages, deferWrites = false) => {
     const openapiFilesFromDocsConfig = await getOpenApiFilesFromConfig('docs', docsConfig, localSchema);
     openApiFiles.push(...openapiFilesFromDocsConfig);
     const pagesAcc = {};
+    const writes = [];
+    const planWrites = deferWrites || (graphqlPages != null && Object.keys(graphqlPages).length > 0);
     const { newNav, newOpenApiFiles } = await generateOpenApiFromDocsConfig(docsConfig.navigation, openApiFiles, pagesAcc, {
         overwrite: true,
         writeFiles: true,
         targetDir,
         localSchema,
         invalidSpecFiles,
+        ...(planWrites
+            ? {
+                writeFile: (filename, content) => {
+                    writes.push({ filename, content });
+                },
+            }
+            : {}),
     });
+    const flushWrites = async () => {
+        await Promise.all(writes.map(({ filename, content }) => fse.outputFile(filename, content)));
+    };
+    if (graphqlPages) {
+        assertNoGeneratedRouteCollisions({ label: 'GraphQL', pages: graphqlPages }, { label: 'OpenAPI', pages: pagesAcc });
+    }
+    if (!deferWrites)
+        await flushWrites();
     return {
         newDocsConfig: { ...docsConfig, navigation: newNav },
         pagesAcc,
         openApiFiles: [...openApiFiles, ...newOpenApiFiles],
+        flushWrites,
     };
 };

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

@@ -7,6 +7,7 @@ export declare const generateOpenApiFromDocsConfig: (navigation: NavigationConfi
     targetDir?: string;
     localSchema?: boolean;
     invalidSpecFiles?: InvalidSpecFile[];
+    writeFile?: (filename: string, content: string) => void | Promise<void>;
 }) => Promise<{
     newNav: NavigationConfig;
     newOpenApiFiles: OpenApiFile[];

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

@@ -6,7 +6,7 @@ import * as path from 'path';
 import { findInvalidSpecFile } from '../../invalidSpecFiles.js';
 const DEFAULT_OUTPUT_DIR = 'api-reference';
 export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pagesAcc, opts) => {
-    const { overwrite, writeFiles, targetDir, localSchema, invalidSpecFiles } = opts;
+    const { overwrite, writeFiles, targetDir, localSchema, invalidSpecFiles, writeFile } = opts;
     const newOpenApiFiles = [];
     const openApiFilePromises = new Map();
     async function processOpenApiInNav(nav) {
@@ -55,6 +55,7 @@ export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pa
                 outDirBasePath: path.join(targetDir ?? '', 'src', '_props'),
                 overwrite,
                 localSchema,
+                writeFile,
             });
             Object.entries(pagesAccFromGeneratedOpenApiPages).forEach(([key, value]) => {
                 pagesAcc[key] = value;
@@ -173,6 +174,7 @@ export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pa
                                 outDirBasePath: path.join(targetDir ?? '', 'src', '_props'),
                                 overwrite,
                                 localSchema,
+                                writeFile,
                             }, findNavGroup);
                         }
                         else {
@@ -192,6 +194,7 @@ export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pa
                                 outDirBasePath: path.join(targetDir ?? '', 'src', '_props'),
                                 overwrite,
                                 localSchema,
+                                writeFile,
                             }, findNavGroup);
                         }
                         await Promise.all(writePromises);

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

@@ -0,0 +1,8 @@
+import type { DecoratedNavigationPage } from '@mintlify/models';
+export declare const getGeneratedRouteKey: (route: string) => string;
+type GeneratedRoutes = {
+    label: string;
+    pages: Record<string, DecoratedNavigationPage>;
+};
+export declare function assertNoGeneratedRouteCollisions(first: GeneratedRoutes, second: GeneratedRoutes): void;
+export {};

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

@@ -0,0 +1,10 @@
+export const getGeneratedRouteKey = (route) => route.replaceAll('\\', '/').normalize('NFC').toLowerCase();
+export function assertNoGeneratedRouteCollisions(first, second) {
+    const firstRoutes = new Map(Object.keys(first.pages).map((route) => [getGeneratedRouteKey(route), route]));
+    for (const secondRoute of Object.keys(second.pages)) {
+        const firstRoute = firstRoutes.get(getGeneratedRouteKey(secondRoute));
+        if (firstRoute) {
+            throw new Error(`Generated ${first.label} route "${firstRoute}" collides with generated ${second.label} route "${secondRoute}"`);
+        }
+    }
+}

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

@@ -28,3 +28,6 @@ export { getOpenApiFilesFromConfig } from '../read/getOpenApiFilesFromConfig.js'
 export { generateAsyncApiDivisions } from './generateAsyncApiDivisions.js';
 export { generateAsyncApiFromDocsConfig } from './generateAsyncApiFromDocsConfig.js';
 export { getCustomLanguages } from './getCustomLanguages.js';
+export { generateGraphqlDivisions, generateGraphqlDivisionsFromDocsConfig, getGraphqlRouteKey, isRemoteGraphqlSource, loadGraphqlSdlSource, loadRemoteGraphqlSdl, writeGraphqlArtifacts, } from './generateGraphqlDivisions.js';
+export { assertNoGeneratedRouteCollisions, getGeneratedRouteKey, } from './generatedRouteCollisions.js';
+export type { GeneratedGraphqlPage, GenerateGraphqlDivisionsResult, GraphqlSourceLoader, } from './generateGraphqlDivisions.js';

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

@@ -1,6 +1,7 @@
 import { getConfigPath } from '../../../utils.js';
 import { DocsConfigUpdater } from '../ConfigUpdater.js';
 import { generateAsyncApiDivisions } from './generateAsyncApiDivisions.js';
+import { generateGraphqlDivisionsFromDocsConfig, loadGraphqlSdlSource, writeGraphqlArtifacts, } from './generateGraphqlDivisions.js';
 import { generateOpenApiDivisions } from './generateOpenApiDivisions.js';
 import { getCustomLanguages } from './getCustomLanguages.js';
 const NOT_CORRECT_PATH_ERROR = 'must be run in a directory where a docs.json file exists.';
@@ -18,14 +19,27 @@ export async function updateDocsConfigFile({ contentDirectoryPath, openApiFiles,
         throw Error(NOT_CORRECT_PATH_ERROR);
     }
     const customLanguages = await getCustomLanguages({ config: docsConfig, contentDirectoryPath });
-    const { newDocsConfig: docsConfigWithOpenApiPages, pagesAcc: pagesAccWithOpenApiPages, openApiFiles: newOpenApiFiles, } = !disableOpenApi
-        ? await generateOpenApiDivisions(docsConfig, openApiFiles, undefined, localSchema, invalidSpecFiles)
-        : { newDocsConfig: docsConfig, pagesAcc: {}, openApiFiles: openApiFiles };
-    const { newDocsConfig, pagesAcc: pagesAccWithAsyncApiPages, asyncApiFiles: newAsyncApiFiles, } = await generateAsyncApiDivisions(docsConfigWithOpenApiPages, asyncApiFiles, undefined, localSchema);
-    const pagesAcc = { ...pagesAccWithOpenApiPages, ...pagesAccWithAsyncApiPages };
-    await DocsConfigUpdater.writeConfigFile(newDocsConfig);
+    const graphqlResult = await generateGraphqlDivisionsFromDocsConfig(docsConfig, (source) => loadGraphqlSdlSource(source, contentDirectoryPath));
+    const { newDocsConfig: docsConfigWithGraphqlPages, pagesAcc: pagesAccWithGraphqlPages } = graphqlResult;
+    const { newDocsConfig: docsConfigWithOpenApiPages, pagesAcc: pagesAccWithOpenApiPages, openApiFiles: newOpenApiFiles, flushWrites: flushOpenApiWrites, } = !disableOpenApi
+        ? await generateOpenApiDivisions(docsConfigWithGraphqlPages, openApiFiles, undefined, localSchema, invalidSpecFiles, pagesAccWithGraphqlPages, true)
+        : {
+            newDocsConfig: docsConfigWithGraphqlPages,
+            pagesAcc: {},
+            openApiFiles: openApiFiles,
+            flushWrites: async () => { },
+        };
+    const { newDocsConfig: docsConfigWithAsyncApiPages, pagesAcc: pagesAccWithAsyncApiPages, asyncApiFiles: newAsyncApiFiles, flushWrites: flushAsyncApiWrites, } = await generateAsyncApiDivisions(docsConfigWithOpenApiPages, asyncApiFiles, undefined, localSchema, pagesAccWithGraphqlPages, true, true);
+    const pagesAcc = {
+        ...pagesAccWithOpenApiPages,
+        ...pagesAccWithAsyncApiPages,
+        ...pagesAccWithGraphqlPages,
+    };
+    await Promise.all([flushOpenApiWrites(), flushAsyncApiWrites()]);
+    await writeGraphqlArtifacts(graphqlResult);
+    await DocsConfigUpdater.writeConfigFile(docsConfigWithAsyncApiPages);
     return {
-        docsConfig: newDocsConfig,
+        docsConfig: docsConfigWithAsyncApiPages,
         pagesAcc,
         newOpenApiFiles,
         newAsyncApiFiles,
@@ -38,3 +52,5 @@ export { getOpenApiFilesFromConfig } from '../read/getOpenApiFilesFromConfig.js'
 export { generateAsyncApiDivisions } from './generateAsyncApiDivisions.js';
 export { generateAsyncApiFromDocsConfig } from './generateAsyncApiFromDocsConfig.js';
 export { getCustomLanguages } from './getCustomLanguages.js';
+export { generateGraphqlDivisions, generateGraphqlDivisionsFromDocsConfig, getGraphqlRouteKey, isRemoteGraphqlSource, loadGraphqlSdlSource, loadRemoteGraphqlSdl, writeGraphqlArtifacts, } from './generateGraphqlDivisions.js';
+export { assertNoGeneratedRouteCollisions, getGeneratedRouteKey, } from './generatedRouteCollisions.js';

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

@@ -0,0 +1,18 @@
+import { request } from 'node:https';
+import type { LookupFunction } from 'node:net';
+export declare const MAX_GRAPHQL_SCHEMA_BYTES: number;
+export type ResolvedAddress = {
+    address: string;
+    family: 4 | 6;
+};
+type ResolveHostname = (hostname: string) => Promise<ResolvedAddress[]>;
+type HttpsRequest = typeof request;
+export declare const isGlobalIpAddress: (address: string) => boolean;
+export declare function createPinnedLookup(resolved: ResolvedAddress): LookupFunction;
+export declare function loadRemoteGraphqlSdl(source: string, options?: {
+    timeoutMs?: number;
+    maxBytes?: number;
+    resolveHostname?: ResolveHostname;
+    requestImpl?: HttpsRequest;
+}): Promise<string>;
+export {};