@mintlify/prebuild 1.0.1537 → 1.0.1539

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

@@ -1,8 +1,11 @@
-import { parseGraphqlSelector, resolveGraphqlOperation, } from '@mintlify/common';
+import { getNamedGraphqlType, parseGraphqlSelector, resolveGraphqlOperation, } from '@mintlify/common';
 import { parseGraphqlSdl } from '@mintlify/scraping';
 import fse from 'fs-extra';
+import kebabCase from 'lodash/kebabCase.js';
+import { createHash } from 'node:crypto';
 import { open } from 'node:fs/promises';
 import path from 'node:path';
+import { addWarning } from '../../warnings.js';
 import { getGeneratedRouteKey } from './generatedRouteCollisions.js';
 import { loadRemoteGraphqlSdl, MAX_GRAPHQL_SCHEMA_BYTES } from './loadRemoteGraphqlSdl.js';
 const DEFAULT_OUTPUT_DIR = 'graphql-reference';
@@ -13,11 +16,71 @@ function graphqlConfig(config) {
         ? { source: config, directory: DEFAULT_OUTPUT_DIR }
         : { source: config.source, directory: config.directory ?? DEFAULT_OUTPUT_DIR };
 }
-function makePage(source, directory, kind, name, entry) {
+function getPathSegments(names) {
+    const firstNames = new Map();
+    for (const name of names) {
+        const key = name.toLowerCase();
+        const current = firstNames.get(key);
+        if (current === undefined || name < current)
+            firstNames.set(key, name);
+    }
+    const renamed = names.filter((name) => firstNames.get(name.toLowerCase()) !== name);
+    const segmentCounts = new Map();
+    for (const name of renamed) {
+        const segment = kebabCase(name);
+        segmentCounts.set(segment, (segmentCounts.get(segment) ?? 0) + 1);
+    }
+    return new Map(names.map((name) => {
+        const firstName = firstNames.get(name.toLowerCase());
+        if (firstName === name)
+            return [name, name];
+        const kebabName = kebabCase(name);
+        const segment = kebabName.includes('-') && segmentCounts.get(kebabName) === 1
+            ? kebabName
+            : `${kebabName ? `${kebabName}-` : ''}${createHash('sha256').update(name).digest('hex').slice(0, 6)}`;
+        addWarning({
+            type: 'graphql',
+            message: `GraphQL name "${name}" shares its URL with "${firstName}", so its page uses "${segment}"`,
+        });
+        return [name, segment];
+    }));
+}
+const typePathCache = new WeakMap();
+const fieldSegmentCache = new WeakMap();
+function getTypePath(reference, name) {
+    let typePaths = typePathCache.get(reference);
+    if (!typePaths) {
+        typePaths = getPathSegments(reference.types.filter((type) => isDocumentedType(reference, type)).map((type) => type.name));
+        typePathCache.set(reference, typePaths);
+    }
+    return typePaths.get(name);
+}
+function getFieldSegment(fields, name) {
+    let segments = fieldSegmentCache.get(fields);
+    if (!segments) {
+        segments = getPathSegments(fields.map((field) => field.name));
+        fieldSegmentCache.set(fields, segments);
+    }
+    return segments.get(name);
+}
+function getOperationPath(reference, rootType, name) {
+    let typeName = rootType;
+    return path.posix.join(...name.split('.').map((fieldName) => {
+        const parent = reference.types.find((type) => type.name === typeName);
+        const fields = parent?.kind === 'object' || parent?.kind === 'interface' ? parent.fields : [];
+        const field = fields.find((candidate) => candidate.name === fieldName);
+        typeName = field ? getNamedGraphqlType(field.type) : undefined;
+        return getFieldSegment(fields, fieldName) ?? fieldName;
+    }));
+}
+function makePage(reference, source, directory, kind, name, entry) {
     const section = kind === 'query' ? 'queries' : kind === 'mutation' ? 'mutations' : 'types';
     const sectionPath = path.posix.join(directory, section);
+    const pagePath = kind === 'type'
+        ? (getTypePath(reference, name) ?? name)
+        : getOperationPath(reference, kind === 'query' ? reference.queryType : reference.mutationType, name);
     return {
-        slug: path.posix.join(sectionPath, ...name.split('.')),
+        slug: path.posix.join(sectionPath, pagePath),
         directory: path.posix.dirname(sectionPath),
         title: name.slice(name.lastIndexOf('.') + 1),
         ...('description' in entry && entry.description ? { description: entry.description } : {}),
@@ -34,10 +97,22 @@ const DOCUMENTED_TYPE_KINDS = [
     'interface',
     'union',
     'enum',
+    'scalar',
 ];
+function isReferencedType(reference, name) {
+    return reference.types.some((type) => ('fields' in type &&
+        type.fields.some((field) => getNamedGraphqlType(field.type) === name ||
+            ('arguments' in field &&
+                field.arguments.some((arg) => getNamedGraphqlType(arg.type) === name)))) ||
+        ('possibleTypes' in type && type.possibleTypes.includes(name)));
+}
 function isDocumentedType(reference, type) {
-    const roots = [reference.queryType, reference.mutationType, reference.subscriptionType];
-    return !roots.includes(type.name) && DOCUMENTED_TYPE_KINDS.includes(type.kind);
+    if (type.name === reference.queryType || type.name === reference.mutationType)
+        return false;
+    if (type.name === reference.subscriptionType && !isReferencedType(reference, type.name)) {
+        return false;
+    }
+    return DOCUMENTED_TYPE_KINDS.includes(type.kind);
 }
 function makeSelectedPage(reference, source, directory, selector) {
     const label = `GraphQL ${selector.kind} ${selector.name}`;
@@ -46,12 +121,12 @@ function makeSelectedPage(reference, source, directory, selector) {
         if (!type || !isDocumentedType(reference, type)) {
             throw new Error(`${label} not found in ${source}`);
         }
-        return makePage(source, directory, 'type', selector.name, type);
+        return makePage(reference, source, directory, 'type', selector.name, type);
     }
     const resolved = resolveGraphqlOperation(reference, selector);
     if (!resolved)
         throw new Error(`${label} not found in ${source}`);
-    return makePage(source, directory, selector.kind, selector.name, resolved.field);
+    return makePage(reference, source, directory, selector.kind, selector.name, resolved.field);
 }
 function generatePages(reference, source, directory) {
     const typeByName = new Map(reference.types.map((type) => [type.name, type]));
@@ -71,16 +146,16 @@ function generatePages(reference, source, directory) {
         queries: queryFields
             .slice()
             .sort(byName)
-            .map((field) => makePage(source, directory, 'query', field.name, field)),
+            .map((field) => makePage(reference, source, directory, 'query', field.name, field)),
         mutations: mutationFields
             .slice()
             .sort(byName)
-            .map((field) => makePage(source, directory, 'mutation', field.name, field)),
+            .map((field) => makePage(reference, source, directory, 'mutation', field.name, field)),
         types: reference.types
             .filter((type) => isDocumentedType(reference, type))
             .slice()
             .sort(byName)
-            .map((type) => makePage(source, directory, 'type', type.name, type)),
+            .map((type) => makePage(reference, source, directory, 'type', type.name, type)),
     };
 }
 function mdxStub(page) {

package/dist/prebuild/warnings.d.ts

@@ -1,5 +1,5 @@
 export type Warning = {
-    type: 'missing-file' | 'missing-nav-page' | 'openapi' | 'invalid-import-path' | 'import-resolution-error' | 'default-import-no-default-export' | 'export-collision' | 'undeclared-package' | 'package-import-conflict' | 'parse-error';
+    type: 'missing-file' | 'missing-nav-page' | 'openapi' | 'invalid-import-path' | 'import-resolution-error' | 'default-import-no-default-export' | 'export-collision' | 'undeclared-package' | 'package-import-conflict' | 'parse-error' | 'graphql';
     message: string;
     file?: string;
     line?: number;