openapi-contract-kit 0.0.1 → 0.0.3

package/dist/src/generator/model.js

@@ -0,0 +1,278 @@
+import { resolve } from 'node:path';
+import { DocumentStore, escapePointerSegment, isRecord, locationOf, pointerChild, requireRecord, } from './documents.js';
+import { SchemaRegistry, toPascalIdentifier } from './schemaModel.js';
+const HTTP_METHODS = [
+    'delete',
+    'get',
+    'head',
+    'options',
+    'patch',
+    'post',
+    'put',
+    'trace',
+];
+const JSON_MEDIA_TYPE = 'application/json';
+class ModelBuilder {
+    #documents = new DocumentStore();
+    #registry = null;
+    #rootDocument = null;
+    #rootPath = null;
+    async build(specPath) {
+        this.#rootPath = resolve(specPath);
+        this.#rootDocument = await this.#documents.load(this.#rootPath);
+        this.#registry = new SchemaRegistry(this.#documents, this.#rootPath);
+        this.#validateOpenApiRoot();
+        this.#seedComponentSchemas();
+        await this.#seedResponseSchemas();
+        const operations = await this.#buildOperations(this.#collectOperationDrafts());
+        return {
+            operations: operations.sort((left, right) => left.name.localeCompare(right.name)),
+            schemas: await this.#registry.build(),
+        };
+    }
+    #getRegistry() {
+        if (this.#registry === null) {
+            throw new Error('OpenAPI model registry is unavailable');
+        }
+        return this.#registry;
+    }
+    #getRootDocument() {
+        if (this.#rootDocument === null) {
+            throw new Error('OpenAPI root document is unavailable');
+        }
+        return this.#rootDocument;
+    }
+    #getRootPath() {
+        if (this.#rootPath === null) {
+            throw new Error('OpenAPI root path is unavailable');
+        }
+        return this.#rootPath;
+    }
+    #validateOpenApiRoot() {
+        const rootDocument = this.#getRootDocument();
+        const rootPath = this.#getRootPath();
+        const version = rootDocument.openapi;
+        if (typeof version !== 'string' || !version.startsWith('3.1.')) {
+            throw new Error(`OpenAPI document "${rootPath}" must use OpenAPI 3.1`);
+        }
+        requireRecord(rootDocument.paths, locationOf(rootPath, '/paths'), 'OpenAPI paths');
+    }
+    #seedComponentSchemas() {
+        const rootDocument = this.#getRootDocument();
+        const rootPath = this.#getRootPath();
+        const components = rootDocument.components;
+        const schemas = isRecord(components) ? components.schemas : undefined;
+        if (schemas === undefined) {
+            return;
+        }
+        const schemaRecord = requireRecord(schemas, locationOf(rootPath, '/components/schemas'), 'OpenAPI component schemas');
+        for (const componentName of Object.keys(schemaRecord).sort()) {
+            this.#getRegistry().register(Reflect.get(schemaRecord, componentName), {
+                documentPath: rootPath,
+                pointer: `/components/schemas/${escapePointerSegment(componentName)}`,
+            }, componentName);
+        }
+    }
+    async #seedResponseSchemas() {
+        const rootDocument = this.#getRootDocument();
+        const rootPath = this.#getRootPath();
+        const components = rootDocument.components;
+        const responses = isRecord(components) ? components.responses : undefined;
+        if (responses === undefined) {
+            return;
+        }
+        const responseRecord = requireRecord(responses, locationOf(rootPath, '/components/responses'), 'OpenAPI component responses');
+        for (const responseName of Object.keys(responseRecord).sort()) {
+            const context = {
+                documentPath: rootPath,
+                pointer: `/components/responses/${escapePointerSegment(responseName)}`,
+            };
+            const resolved = await this.#resolveReferenceObject(Reflect.get(responseRecord, responseName), context, 'Response');
+            const body = this.#readJsonBody(resolved.value, resolved.context, 'Response');
+            if (body !== null) {
+                this.#getRegistry().register(body.schema, body.context, responseName);
+            }
+        }
+    }
+    #collectOperationDrafts() {
+        const rootDocument = this.#getRootDocument();
+        const rootPath = this.#getRootPath();
+        const paths = requireRecord(rootDocument.paths, locationOf(rootPath, '/paths'), 'OpenAPI paths');
+        const drafts = [];
+        const operationIds = new Set();
+        for (const path of Object.keys(paths).sort()) {
+            const pathPointer = `/paths/${escapePointerSegment(path)}`;
+            const pathItem = requireRecord(Reflect.get(paths, path), locationOf(rootPath, pathPointer), 'Path item');
+            if (pathItem.$ref !== undefined) {
+                throw new Error(`Referenced path items are unsupported at ${path}`);
+            }
+            if (Array.isArray(pathItem.parameters) &&
+                pathItem.parameters.length > 0) {
+                throw new Error(`Path parameters are unsupported at ${path}`);
+            }
+            for (const method of HTTP_METHODS) {
+                const rawOperation = pathItem[method];
+                if (rawOperation === undefined) {
+                    continue;
+                }
+                const operation = requireRecord(rawOperation, locationOf(rootPath, `${pathPointer}/${method}`), 'Operation');
+                const operationId = operation.operationId;
+                if (typeof operationId !== 'string' || operationId.length === 0) {
+                    throw new Error(`Missing operationId for ${method.toUpperCase()} ${path}`);
+                }
+                if (operationIds.has(operationId)) {
+                    throw new Error(`Duplicate operationId "${operationId}"`);
+                }
+                if (Array.isArray(operation.parameters) &&
+                    operation.parameters.length > 0) {
+                    throw new Error(`Operation parameters are unsupported for ${operationId}`);
+                }
+                operationIds.add(operationId);
+                drafts.push({ method, operation, operationId, path, pathPointer });
+            }
+        }
+        const draftsWithLeaves = drafts.map((draft) => {
+            const segments = draft.operationId
+                .split(/[^A-Za-z0-9_$]+/u)
+                .filter(Boolean);
+            return {
+                ...draft,
+                leafName: toPascalIdentifier(segments.at(-1) ?? draft.operationId, 'Operation'),
+            };
+        });
+        const leafCounts = new Map();
+        for (const draft of draftsWithLeaves) {
+            const key = draft.leafName.toLowerCase();
+            leafCounts.set(key, (leafCounts.get(key) ?? 0) + 1);
+        }
+        const names = new Set();
+        return draftsWithLeaves.map((draft) => {
+            const name = leafCounts.get(draft.leafName.toLowerCase()) === 1
+                ? draft.leafName
+                : toPascalIdentifier(draft.operationId, 'Operation');
+            const key = name.toLowerCase();
+            if (names.has(key)) {
+                throw new Error(`Operation name collision for "${name}"`);
+            }
+            names.add(key);
+            return {
+                method: draft.method,
+                name,
+                operation: draft.operation,
+                operationId: draft.operationId,
+                path: draft.path,
+                pathPointer: draft.pathPointer,
+            };
+        });
+    }
+    async #buildOperations(drafts) {
+        const operations = [];
+        const rootPath = this.#getRootPath();
+        for (const draft of drafts) {
+            const context = {
+                documentPath: rootPath,
+                pointer: `${draft.pathPointer}/${draft.method}`,
+            };
+            operations.push({
+                method: draft.method.toUpperCase(),
+                name: draft.name,
+                operationId: draft.operationId,
+                path: draft.path,
+                request: await this.#buildRequest(draft.operation, context, draft.name),
+                responses: await this.#buildResponses(draft.operation, context, draft.name),
+            });
+        }
+        return operations;
+    }
+    async #buildRequest(operation, context, operationName) {
+        if (operation.requestBody === undefined) {
+            return { schemaName: null };
+        }
+        const requestContext = {
+            documentPath: context.documentPath,
+            pointer: pointerChild(context.pointer, 'requestBody'),
+        };
+        const resolved = await this.#resolveReferenceObject(operation.requestBody, requestContext, 'Request body');
+        if (resolved.value.required !== true) {
+            throw new Error(`Optional request bodies are unsupported for ${operationName}`);
+        }
+        const body = this.#readJsonBody(resolved.value, resolved.context, 'Request body');
+        if (body === null) {
+            throw new Error(`Request body for ${operationName} has no JSON schema`);
+        }
+        return {
+            schemaName: await this.#getRegistry().schemaNameFor(body.schema, body.context, `${operationName}Request`),
+        };
+    }
+    async #buildResponses(operation, context, operationName) {
+        const responsesPointer = pointerChild(context.pointer, 'responses');
+        const responses = requireRecord(operation.responses, locationOf(context.documentPath, responsesPointer), 'Operation responses');
+        const result = [];
+        for (const statusKey of Object.keys(responses).sort((left, right) => Number(left) - Number(right))) {
+            if (!/^\d{3}$/u.test(statusKey)) {
+                throw new Error(`Response status "${statusKey}" is unsupported for ${operationName}`);
+            }
+            const status = Number(statusKey);
+            if (status < 100 || status > 599) {
+                throw new Error(`Invalid response status "${statusKey}" for ${operationName}`);
+            }
+            const responseContext = {
+                documentPath: context.documentPath,
+                pointer: pointerChild(responsesPointer, statusKey),
+            };
+            const resolved = await this.#resolveReferenceObject(Reflect.get(responses, statusKey), responseContext, 'Response');
+            const body = this.#readJsonBody(resolved.value, resolved.context, 'Response');
+            const schemaName = body === null
+                ? null
+                : await this.#getRegistry().schemaNameFor(body.schema, body.context, `${operationName}Response${statusKey}`);
+            result.push({
+                isSuccess: status >= 200 && status <= 299,
+                schemaName,
+                status,
+            });
+        }
+        if (result.length === 0) {
+            throw new Error(`Operation ${operationName} must document a response`);
+        }
+        return result;
+    }
+    #readJsonBody(value, context, label) {
+        if (value.content === undefined) {
+            return null;
+        }
+        const content = requireRecord(value.content, locationOf(context.documentPath, pointerChild(context.pointer, 'content')), `${label} content`);
+        const mediaTypes = Object.keys(content);
+        if (mediaTypes.length === 0) {
+            return null;
+        }
+        if (mediaTypes.length !== 1 || mediaTypes[0] !== JSON_MEDIA_TYPE) {
+            throw new Error(`${label} at ${locationOf(context.documentPath, context.pointer)} must use only ${JSON_MEDIA_TYPE}`);
+        }
+        const media = requireRecord(content[JSON_MEDIA_TYPE], locationOf(context.documentPath, pointerChild(pointerChild(context.pointer, 'content'), JSON_MEDIA_TYPE)), `${label} media type`);
+        if (media.schema === undefined) {
+            throw new Error(`${label} at ${locationOf(context.documentPath, context.pointer)} has no schema`);
+        }
+        return {
+            context: {
+                documentPath: context.documentPath,
+                pointer: pointerChild(pointerChild(pointerChild(context.pointer, 'content'), JSON_MEDIA_TYPE), 'schema'),
+            },
+            schema: media.schema,
+        };
+    }
+    async #resolveReferenceObject(value, context, label, seen = new Set()) {
+        const object = requireRecord(value, locationOf(context.documentPath, context.pointer), label);
+        if (object.$ref === undefined) {
+            return { context, value: object };
+        }
+        const resolved = await this.#documents.resolveReference(object.$ref, context.documentPath);
+        if (seen.has(resolved.canonicalKey)) {
+            throw new Error(`Cyclic ${label.toLowerCase()} reference at ${resolved.canonicalKey}`);
+        }
+        seen.add(resolved.canonicalKey);
+        return this.#resolveReferenceObject(resolved.value, { documentPath: resolved.documentPath, pointer: resolved.pointer }, label, seen);
+    }
+}
+export async function buildOpenApiModel(specPath) {
+    return new ModelBuilder().build(specPath);
+}

package/dist/src/generator/schemaModel.d.ts

@@ -0,0 +1,9 @@
+import type { DocumentContext, SchemaEntry } from './types.js';
+export declare function toPascalIdentifier(value: string, fallback?: string): string;
+export declare class SchemaRegistry {
+    #private;
+    constructor(documents: import('./documents.js').DocumentStore, rootPath: string);
+    register(rawSchema: unknown, context: DocumentContext, suggestedName: string): string;
+    schemaNameFor(schema: unknown, context: DocumentContext, suggestedName: string): Promise<string>;
+    build(): Promise<readonly SchemaEntry[]>;
+}

package/dist/src/generator/schemaModel.js

@@ -0,0 +1,408 @@
+import { basename, extname } from 'node:path';
+import { isRecord, locationOf, pointerChild, requireRecord, } from './documents.js';
+const SCHEMA_TYPES = new Set([
+    'array',
+    'boolean',
+    'integer',
+    'null',
+    'number',
+    'object',
+    'string',
+]);
+const ANNOTATION_KEYWORDS = new Set([
+    '$anchor',
+    '$comment',
+    '$defs',
+    '$id',
+    '$schema',
+    'default',
+    'deprecated',
+    'description',
+    'discriminator',
+    'example',
+    'examples',
+    'externalDocs',
+    'readOnly',
+    'title',
+    'writeOnly',
+    'xml',
+]);
+const ASSERTION_KEYWORDS = new Set([
+    '$ref',
+    'additionalProperties',
+    'allOf',
+    'anyOf',
+    'const',
+    'enum',
+    'exclusiveMaximum',
+    'exclusiveMinimum',
+    'format',
+    'items',
+    'maxLength',
+    'maximum',
+    'minLength',
+    'minimum',
+    'oneOf',
+    'pattern',
+    'properties',
+    'required',
+    'type',
+]);
+const RESERVED_IDENTIFIERS = new Set([
+    'any',
+    'boolean',
+    'constructor',
+    'declare',
+    'default',
+    'enum',
+    'extends',
+    'false',
+    'infer',
+    'interface',
+    'keyof',
+    'never',
+    'null',
+    'number',
+    'object',
+    'makeresult',
+    'string',
+    'symbol',
+    'true',
+    'type',
+    'undefined',
+    'unknown',
+    'result',
+    'validationissue',
+    'validationpath',
+]);
+function requireNumber(value, keyword, location) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new Error(`Schema keyword "${keyword}" at ${location} must be finite`);
+    }
+    return value;
+}
+function requirePrimitive(value, keyword, location) {
+    if (value !== null &&
+        typeof value !== 'string' &&
+        typeof value !== 'number' &&
+        typeof value !== 'boolean') {
+        throw new Error(`Schema keyword "${keyword}" at ${location} supports primitive JSON values only`);
+    }
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+        throw new Error(`Schema keyword "${keyword}" at ${location} must be finite`);
+    }
+    return value;
+}
+function isSchemaType(value) {
+    return typeof value === 'string' && SCHEMA_TYPES.has(value);
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((item) => typeof item === 'string'));
+}
+export function toPascalIdentifier(value, fallback = 'Schema') {
+    const words = value
+        .replace(/([a-z0-9])([A-Z])/gu, '$1 $2')
+        .split(/[^A-Za-z0-9_$]+/u)
+        .filter(Boolean);
+    let identifier = words
+        .map((word) => `${word[0] ?? ''}${word.slice(1)}`)
+        .map((word) => `${word[0]?.toUpperCase() ?? ''}${word.slice(1)}`)
+        .join('');
+    if (identifier.length === 0) {
+        identifier = fallback;
+    }
+    if (!/^[A-Za-z_$]/u.test(identifier)) {
+        identifier = `${fallback}${identifier}`;
+    }
+    if (RESERVED_IDENTIFIERS.has(identifier.toLowerCase())) {
+        identifier = `${fallback}${identifier}`;
+    }
+    return identifier;
+}
+export class SchemaRegistry {
+    #documents;
+    #names = new Map();
+    #rawSchemas = new Map();
+    #rootPath;
+    constructor(documents, rootPath) {
+        this.#documents = documents;
+        this.#rootPath = rootPath;
+    }
+    register(rawSchema, context, suggestedName) {
+        const canonicalKey = locationOf(context.documentPath, context.pointer);
+        const existing = this.#rawSchemas.get(canonicalKey);
+        if (existing !== undefined) {
+            return existing.name;
+        }
+        const name = toPascalIdentifier(suggestedName);
+        const nameKey = name.toLowerCase();
+        const existingCanonicalKey = this.#names.get(nameKey);
+        if (existingCanonicalKey !== undefined &&
+            existingCanonicalKey !== canonicalKey) {
+            throw new Error(`Schema name collision for "${name}" at ${canonicalKey} and ${existingCanonicalKey}`);
+        }
+        this.#names.set(nameKey, canonicalKey);
+        this.#rawSchemas.set(canonicalKey, {
+            context,
+            name,
+            rawSchema,
+        });
+        return name;
+    }
+    async schemaNameFor(schema, context, suggestedName) {
+        if (isRecord(schema) &&
+            schema.$ref !== undefined &&
+            Object.keys(schema).length === 1) {
+            const resolved = await this.#documents.resolveReference(schema.$ref, context.documentPath);
+            return this.register(resolved.value, { documentPath: resolved.documentPath, pointer: resolved.pointer }, this.#suggestReferenceName(resolved));
+        }
+        return this.register(schema, context, suggestedName);
+    }
+    async build() {
+        const schemas = await this.#normaliseAllSchemas();
+        this.#rejectReferenceCycles(schemas);
+        return schemas.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    #suggestReferenceName(resolved) {
+        const segments = resolved.pointer.split('/').filter(Boolean);
+        const pointerName = segments.at(-1) ?? 'Schema';
+        if (resolved.documentPath === this.#rootPath) {
+            return pointerName;
+        }
+        const fileName = basename(resolved.documentPath, extname(resolved.documentPath));
+        return `${fileName}-${pointerName}`;
+    }
+    async #normaliseAllSchemas() {
+        const normalised = new Map();
+        const entries = [...this.#rawSchemas.entries()];
+        for (let index = 0; index < entries.length; index += 1) {
+            const entryPair = entries[index];
+            if (entryPair === undefined) {
+                continue;
+            }
+            const [canonicalKey, entry] = entryPair;
+            if (normalised.has(canonicalKey)) {
+                continue;
+            }
+            normalised.set(canonicalKey, {
+                canonicalKey,
+                name: entry.name,
+                schema: await this.#normaliseSchema(entry.rawSchema, entry.context),
+            });
+            for (const nextEntry of this.#rawSchemas.entries()) {
+                if (!entries.some(([key]) => key === nextEntry[0])) {
+                    entries.push(nextEntry);
+                }
+            }
+        }
+        return [...normalised.values()];
+    }
+    async #normaliseSchema(rawSchema, context) {
+        const location = locationOf(context.documentPath, context.pointer);
+        if (typeof rawSchema === 'boolean') {
+            return { booleanSchema: rawSchema, location };
+        }
+        const schema = requireRecord(rawSchema, location, 'Schema');
+        for (const keyword of Object.keys(schema)) {
+            if (!ANNOTATION_KEYWORDS.has(keyword) &&
+                !ASSERTION_KEYWORDS.has(keyword)) {
+                throw new Error(`Unsupported schema keyword "${keyword}" at ${location}`);
+            }
+        }
+        let reference = null;
+        if (schema.$ref !== undefined) {
+            const resolved = await this.#documents.resolveReference(schema.$ref, context.documentPath);
+            reference = this.register(resolved.value, { documentPath: resolved.documentPath, pointer: resolved.pointer }, this.#suggestReferenceName(resolved));
+        }
+        let types = null;
+        if (schema.type !== undefined) {
+            const rawTypes = Array.isArray(schema.type)
+                ? schema.type
+                : [schema.type];
+            if (rawTypes.length === 0) {
+                throw new Error(`Unsupported schema type at ${location}`);
+            }
+            const uniqueTypes = [];
+            for (const type of rawTypes) {
+                if (!isSchemaType(type)) {
+                    throw new Error(`Unsupported schema type at ${location}`);
+                }
+                if (!uniqueTypes.includes(type)) {
+                    uniqueTypes.push(type);
+                }
+            }
+            types = uniqueTypes;
+        }
+        const rawRequired = schema.required;
+        if (rawRequired !== undefined && !isStringArray(rawRequired)) {
+            throw new Error(`Schema required list at ${location} must contain strings`);
+        }
+        const required = rawRequired ?? [];
+        const rawProperties = schema.properties ?? {};
+        requireRecord(rawProperties, location, 'Schema properties');
+        const properties = [];
+        const propertyNames = [
+            ...Object.keys(rawProperties),
+            ...required.filter((property) => !Object.prototype.hasOwnProperty.call(rawProperties, property)),
+        ];
+        for (const propertyName of propertyNames) {
+            const propertySchema = Object.prototype.hasOwnProperty.call(rawProperties, propertyName)
+                ? Reflect.get(rawProperties, propertyName)
+                : true;
+            properties.push({
+                name: propertyName,
+                required: required.includes(propertyName),
+                schema: await this.#normaliseSchema(propertySchema, {
+                    documentPath: context.documentPath,
+                    pointer: pointerChild(pointerChild(context.pointer, 'properties'), propertyName),
+                }),
+            });
+        }
+        let additionalProperties = true;
+        if (schema.additionalProperties !== undefined) {
+            additionalProperties =
+                typeof schema.additionalProperties === 'boolean'
+                    ? schema.additionalProperties
+                    : await this.#normaliseSchema(schema.additionalProperties, {
+                        documentPath: context.documentPath,
+                        pointer: pointerChild(context.pointer, 'additionalProperties'),
+                    });
+        }
+        const normaliseList = async (keyword) => {
+            const rawValue = schema[keyword];
+            if (rawValue === undefined) {
+                return [];
+            }
+            if (!Array.isArray(rawValue) || rawValue.length === 0) {
+                throw new Error(`Schema keyword "${keyword}" at ${location} must be non-empty`);
+            }
+            return Promise.all(rawValue.map((child, index) => this.#normaliseSchema(child, {
+                documentPath: context.documentPath,
+                pointer: pointerChild(pointerChild(context.pointer, keyword), index),
+            })));
+        };
+        const items = schema.items === undefined
+            ? null
+            : await this.#normaliseSchema(schema.items, {
+                documentPath: context.documentPath,
+                pointer: pointerChild(context.pointer, 'items'),
+            });
+        let enumValues = null;
+        if (schema.enum !== undefined) {
+            if (!Array.isArray(schema.enum) || schema.enum.length === 0) {
+                throw new Error(`Schema enum at ${location} must be non-empty`);
+            }
+            enumValues = schema.enum.map((value) => requirePrimitive(value, 'enum', location));
+        }
+        const constValue = schema.const === undefined
+            ? undefined
+            : requirePrimitive(schema.const, 'const', location);
+        let pattern = null;
+        if (schema.pattern !== undefined) {
+            if (typeof schema.pattern !== 'string') {
+                throw new Error(`Schema pattern at ${location} must be a string`);
+            }
+            try {
+                new RegExp(schema.pattern, 'u');
+            }
+            catch {
+                throw new Error(`Schema pattern at ${location} is not valid JavaScript`);
+            }
+            pattern = schema.pattern;
+        }
+        let format = null;
+        if (schema.format !== undefined) {
+            if (schema.format !== 'email') {
+                throw new Error(`Unsupported schema format "${String(schema.format)}" at ${location}`);
+            }
+            format = 'email';
+        }
+        const numberKeyword = (keyword) => {
+            const value = schema[keyword];
+            return value === undefined
+                ? null
+                : requireNumber(value, keyword, location);
+        };
+        const integerKeyword = (keyword) => {
+            const value = numberKeyword(keyword);
+            if (value !== null && (!Number.isInteger(value) || value < 0)) {
+                throw new Error(`Schema keyword "${keyword}" at ${location} must be >= 0`);
+            }
+            return value;
+        };
+        return {
+            additionalProperties,
+            allOf: await normaliseList('allOf'),
+            anyOf: await normaliseList('anyOf'),
+            booleanSchema: null,
+            constValue,
+            enumValues,
+            exclusiveMaximum: numberKeyword('exclusiveMaximum'),
+            exclusiveMinimum: numberKeyword('exclusiveMinimum'),
+            format,
+            items,
+            location,
+            maximum: numberKeyword('maximum'),
+            maxLength: integerKeyword('maxLength'),
+            minimum: numberKeyword('minimum'),
+            minLength: integerKeyword('minLength'),
+            oneOf: await normaliseList('oneOf'),
+            pattern,
+            properties,
+            reference,
+            types,
+        };
+    }
+    #rejectReferenceCycles(schemas) {
+        const schemaByName = new Map(schemas.map((entry) => [entry.name, entry.schema]));
+        const visiting = [];
+        const visited = new Set();
+        const collectReferences = (schema, references) => {
+            if (schema.booleanSchema !== null) {
+                return;
+            }
+            if (schema.reference !== null) {
+                references.add(schema.reference);
+            }
+            for (const property of schema.properties) {
+                collectReferences(property.schema, references);
+            }
+            if (typeof schema.additionalProperties !== 'boolean') {
+                collectReferences(schema.additionalProperties, references);
+            }
+            if (schema.items !== null) {
+                collectReferences(schema.items, references);
+            }
+            for (const children of [schema.allOf, schema.anyOf, schema.oneOf]) {
+                for (const child of children) {
+                    collectReferences(child, references);
+                }
+            }
+        };
+        const visit = (name) => {
+            if (visited.has(name)) {
+                return;
+            }
+            const cycleIndex = visiting.indexOf(name);
+            if (cycleIndex !== -1) {
+                const cycle = [...visiting.slice(cycleIndex), name].join(' -> ');
+                throw new Error(`Cyclic schema reference: ${cycle}`);
+            }
+            const schema = schemaByName.get(name);
+            if (schema === undefined) {
+                throw new Error(`Unresolved schema model reference "${name}"`);
+            }
+            visiting.push(name);
+            const references = new Set();
+            collectReferences(schema, references);
+            for (const reference of [...references].sort()) {
+                visit(reference);
+            }
+            visiting.pop();
+            visited.add(name);
+        };
+        for (const { name } of schemas) {
+            visit(name);
+        }
+    }
+}