Function inlineExternalSchemaDefinitions

scripts/codegen/utils.ts:1451–1566

(
    schema: T,
    externalSchema: Record<string, unknown>,
    externalSchemaFile: string,
    options: { conflictingDefinitionNamePrefix?: string } = {}
)

}

export function inlineExternalSchemaDefinitions<T>(
    schema: T,
    externalSchema: Record<string, unknown>,
    externalSchemaFile: string,
    options: { conflictingDefinitionNamePrefix?: string } = {}
): { schema: T; inlinedDefinitionNames: Set<string> } {
    const cloned = cloneSchemaForCodegen(schema) as Record<string, unknown>;
    const externalRefs = collectExternalSchemaRefNames(cloned).get(externalSchemaFile);
    if (!externalRefs || externalRefs.size === 0) {
        return { schema: cloned as T, inlinedDefinitionNames: new Set<string>() };
    }

    const externalDefinitions = collectDefinitions(externalSchema);
    const reachableDefinitions = collectReachableDefinitionNames(externalSchema, externalRefs);
    const inlinedDefinitionNames = new Set<string>();
    const targetDefinitions = {
        ...((cloned.definitions ?? {}) as Record<string, JSONSchema7Definition>),
    };
    const nameMap = new Map<string, string>();
    const usedNames = new Set([...Object.keys(targetDefinitions), ...reachableDefinitions]);

    for (const name of [...reachableDefinitions].sort()) {
        const definition = externalDefinitions[name];
        if (definition === undefined) continue;

        const existing = targetDefinitions[name];
        if (
            existing !== undefined &&
            stableStringify(normalizeDefinitionForComparison(existing)) !==
                stableStringify(normalizeDefinitionForComparison(definition))
        ) {
            if (!options.conflictingDefinitionNamePrefix) {
                throw new Error(
                    `Cannot inline ${externalSchemaFile}#/definitions/${name}; api.schema.json already defines a different schema with that name.`
                );
            }

            let renamed = `${options.conflictingDefinitionNamePrefix}${name}`;
            let suffix = 2;
            while (usedNames.has(renamed)) {
                renamed = `${options.conflictingDefinitionNamePrefix}${name}${suffix++}`;
            }
            usedNames.add(renamed);
            nameMap.set(name, renamed);
        } else {
            nameMap.set(name, name);
        }
    }

    const rewriteInlinedRefs = (value: unknown): unknown => {
        if (Array.isArray(value)) {
            return value.map((item) => rewriteInlinedRefs(item));
        }

        if (!value || typeof value !== "object") {
            return value;
        }