ormbridge 0.3.0 → 0.4.0

package/dist/parsers/jsonSchema.js

@@ -0,0 +1,1432 @@
+/**
+ * JSON Schema parser. Reads JSON Schema (draft 2020-12, 2019-09 and 7) and OpenAPI 3.x documents
+ * (`components.schemas`) into the shared IR. The input is plain JSON, so no tree-sitter grammar is
+ * needed; YAML is not read because no YAML parser is a dependency of this package.
+ *
+ * Each object schema under `$defs`, `definitions` or `components.schemas` (or a root object schema)
+ * is a model. A property whose schema is a `$ref` to another model is a relation. See the README
+ * section "JSON Schema (`--from json-schema`)" for the complete mapping.
+ */
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { splitWords, toPascalCase, toSnakeCase } from '../naming.js';
+import { describeThrown, err, ok } from '../result.js';
+/** Maximum depth of `$ref` chains, `allOf` nesting and array nesting that is followed. */
+const MAX_DEPTH = 32;
+/** Schema collections that hold named schemas, as JSON pointer segments. */
+const DEFINITION_COLLECTIONS = [
+    ['$defs'],
+    ['definitions'],
+    ['components', 'schemas'],
+];
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function asRecordOrEmpty(value) {
+    return asRecord(value) ?? {};
+}
+function omitKey(record, key) {
+    const copy = { ...record };
+    delete copy[key];
+    return copy;
+}
+function escapePointerSegment(segment) {
+    return segment.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function pointerOf(segments) {
+    return `#${segments.map((segment) => `/${escapePointerSegment(segment)}`).join('')}`;
+}
+function lastSegment(pointer) {
+    const parts = pointer.split('/');
+    const last = parts[parts.length - 1] ?? '';
+    return last.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+/** Reads JSON Schema / OpenAPI documents into the IR. Never throws. */
+export function parseJsonSchema(sources, options) {
+    try {
+        return parseDocuments(sources, options);
+    }
+    catch (thrown) {
+        return err('PARSE_FAILED', `The JSON Schema input could not be converted: ${describeThrown(thrown)}`);
+    }
+}
+function parseDocuments(sources, options) {
+    const ctx = {
+        options,
+        warnings: [],
+        registry: new Map(),
+        modelsByKey: new Map(),
+        enums: new Map(),
+        enumNameByKey: new Map(),
+    };
+    const docs = [];
+    for (const source of sources) {
+        const doc = readDocument(source, ctx);
+        if (!doc.ok) {
+            return doc;
+        }
+        docs.push(doc.value);
+    }
+    const infos = discoverModels(docs, ctx);
+    for (const doc of docs) {
+        registerEnumDefinitions(doc, ctx);
+    }
+    if (infos.length === 0) {
+        return err('NO_MODELS_FOUND', `No object schemas with properties were found in: ${sources.map((source) => source.path).join(', ')}. ` +
+            'A model is an object schema with properties under $defs, definitions or components.schemas, or a root object schema.');
+    }
+    const built = infos.map((info) => buildModel(info, ctx));
+    pairRelations(built, ctx);
+    const models = built.map((model) => finishModel(model, ctx));
+    return ok({
+        models,
+        enums: [...ctx.enums.values()],
+        warnings: ctx.warnings,
+    });
+}
+// ---------------------------------------------------------------------------
+// Documents and references
+// ---------------------------------------------------------------------------
+function readDocument(source, ctx) {
+    const text = source.text.charCodeAt(0) === 0xfeff ? source.text.slice(1) : source.text;
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (thrown) {
+        const isYaml = /\.ya?ml$/i.test(source.path);
+        return err('PARSE_FAILED', `${source.path}: not valid JSON (${describeThrown(thrown)}).` +
+            (isYaml
+                ? ' YAML is not supported because the package has no YAML parser; convert the document to JSON first.'
+                : ''));
+    }
+    const root = asRecord(parsed);
+    if (root === undefined) {
+        return err('PARSE_FAILED', `${source.path}: expected a JSON object at the top level (a JSON Schema or OpenAPI document), found ${Array.isArray(parsed) ? 'an array' : typeof parsed}.`);
+    }
+    const fileUri = pathToFileURL(resolve(source.path)).href;
+    let baseUri = fileUri;
+    const id = asString(root.$id);
+    if (id !== undefined) {
+        try {
+            baseUri = new URL(id, fileUri).href.split('#')[0] ?? fileUri;
+        }
+        catch {
+            ctx.warnings.push(`${source.path}: the $id "${id}" is not a valid URI reference and was ignored.`);
+        }
+    }
+    const doc = {
+        path: source.path,
+        fileUri,
+        baseUri,
+        root,
+        isOpenApi: typeof root.openapi === 'string' || typeof root.swagger === 'string',
+    };
+    for (const uri of new Set([fileUri, baseUri])) {
+        const existing = ctx.registry.get(uri);
+        if (existing !== undefined && existing !== doc) {
+            ctx.warnings.push(`${source.path}: the identifier ${uri} is also used by ${existing.path}; references to it resolve to the first file.`);
+            continue;
+        }
+        ctx.registry.set(uri, doc);
+    }
+    return ok(doc);
+}
+function navigate(doc, segments) {
+    let current = doc.root;
+    for (const segment of segments) {
+        if (Array.isArray(current)) {
+            const index = Number(segment);
+            if (!Number.isInteger(index) || index < 0 || index >= current.length) {
+                return { found: false };
+            }
+            current = current[index];
+        }
+        else {
+            const record = asRecord(current);
+            if (record === undefined || !Object.hasOwn(record, segment)) {
+                return { found: false };
+            }
+            current = record[segment];
+        }
+    }
+    return { found: true, value: current };
+}
+function resolveRef(ctx, ref, from) {
+    let target;
+    let hash = '';
+    let attempted = '';
+    for (const base of new Set([from.baseUri, from.fileUri])) {
+        let url;
+        try {
+            url = new URL(ref, base);
+        }
+        catch {
+            continue;
+        }
+        const withoutHash = url.href.split('#')[0] ?? '';
+        attempted = attempted === '' ? withoutHash : attempted;
+        const found = ctx.registry.get(withoutHash);
+        if (found !== undefined) {
+            target = found;
+            hash = url.hash;
+            break;
+        }
+    }
+    if (target === undefined) {
+        return {
+            ok: false,
+            reason: attempted === ''
+                ? `the reference "${ref}" is not a valid URI reference`
+                : `the reference "${ref}" points to ${attempted}, which is not one of the input files (remote references are not fetched)`,
+        };
+    }
+    let fragment = hash.startsWith('#') ? hash.slice(1) : hash;
+    try {
+        fragment = decodeURIComponent(fragment);
+    }
+    catch {
+        return {
+            ok: false,
+            reason: `the reference "${ref}" has an invalid escape sequence in its fragment`,
+        };
+    }
+    if (fragment !== '' && !fragment.startsWith('/')) {
+        return {
+            ok: false,
+            reason: `the reference "${ref}" uses a named anchor, which is not supported (use a JSON pointer such as #/$defs/Name)`,
+        };
+    }
+    const segments = fragment === ''
+        ? []
+        : fragment
+            .slice(1)
+            .split('/')
+            .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
+    const navigated = navigate(target, segments);
+    if (!navigated.found) {
+        return {
+            ok: false,
+            reason: `the reference "${ref}" does not resolve to anything in ${target.path}`,
+        };
+    }
+    const schema = typeof navigated.value === 'boolean' ? {} : asRecord(navigated.value);
+    if (schema === undefined) {
+        return {
+            ok: false,
+            reason: `the reference "${ref}" does not point to a schema`,
+        };
+    }
+    return {
+        ok: true,
+        located: { doc: target, pointer: pointerOf(segments), schema },
+    };
+}
+function locationKey(located) {
+    return `${located.doc.fileUri}${located.pointer}`;
+}
+// ---------------------------------------------------------------------------
+// Models
+// ---------------------------------------------------------------------------
+/** Merges `allOf` members and sibling `$ref`s into one object shape. */
+function collectShape(schema, doc, ctx, seen, depth) {
+    const shape = {
+        properties: new Map(),
+        required: new Set(),
+        inherited: [],
+        hasUnion: false,
+        hasPatternProperties: false,
+        hasAdditionalSchema: false,
+        hasConditional: false,
+    };
+    if (seen.has(schema) || depth > MAX_DEPTH) {
+        return shape;
+    }
+    seen.add(schema);
+    const parents = [];
+    const ref = asString(schema.$ref);
+    if (ref !== undefined) {
+        parents.push({ $ref: ref });
+    }
+    if (Array.isArray(schema.allOf)) {
+        parents.push(...schema.allOf);
+    }
+    for (const parent of parents) {
+        const member = asRecord(parent);
+        if (member === undefined) {
+            continue;
+        }
+        let memberSchema = member;
+        let memberDoc = doc;
+        const memberRef = asString(member.$ref);
+        if (memberRef !== undefined) {
+            const resolved = resolveRef(ctx, memberRef, doc);
+            if (!resolved.ok) {
+                ctx.warnings.push(`${doc.path}: allOf member skipped because ${resolved.reason}.`);
+                continue;
+            }
+            memberSchema = resolved.located.schema;
+            memberDoc = resolved.located.doc;
+            const inheritedFrom = ctx.modelsByKey.get(locationKey(resolved.located));
+            shape.inherited.push(inheritedFrom?.name ?? lastSegment(resolved.located.pointer));
+        }
+        const inner = collectShape(memberSchema, memberDoc, ctx, seen, depth + 1);
+        for (const [name, value] of inner.properties) {
+            shape.properties.set(name, value);
+        }
+        for (const name of inner.required) {
+            shape.required.add(name);
+        }
+        shape.inherited.push(...inner.inherited);
+        shape.hasUnion ||= inner.hasUnion;
+        shape.hasPatternProperties ||= inner.hasPatternProperties;
+        shape.hasAdditionalSchema ||= inner.hasAdditionalSchema;
+        shape.hasConditional ||= inner.hasConditional;
+    }
+    const properties = asRecord(schema.properties);
+    if (properties !== undefined) {
+        for (const [name, value] of Object.entries(properties)) {
+            shape.properties.set(name, { schema: value, doc });
+        }
+    }
+    if (Array.isArray(schema.required)) {
+        for (const name of schema.required) {
+            if (typeof name === 'string') {
+                shape.required.add(name);
+            }
+        }
+    }
+    shape.hasUnion ||=
+        (Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf)) &&
+            properties === undefined;
+    shape.hasPatternProperties ||=
+        asRecord(schema.patternProperties) !== undefined;
+    shape.hasAdditionalSchema ||=
+        asRecord(schema.additionalProperties) !== undefined;
+    shape.hasConditional ||=
+        schema.if !== undefined ||
+            schema.then !== undefined ||
+            schema.else !== undefined;
+    return shape;
+}
+function sanitizeModelName(raw) {
+    const cleaned = raw
+        .replace(/[^A-Za-z0-9_]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    const name = cleaned === '' ? 'Model' : cleaned;
+    return /^[0-9]/.test(name) ? `_${name}` : name;
+}
+function rootModelName(doc) {
+    const title = asString(doc.root.title);
+    if (title !== undefined && title.trim() !== '') {
+        const pascal = toPascalCase(title);
+        return pascal === '' ? sanitizeModelName(title) : pascal;
+    }
+    const idSource = asString(doc.root.$id) ?? doc.path;
+    const segments = idSource.split(/[\\/]/).filter((s) => s !== '');
+    const file = (segments[segments.length - 1] ?? 'Root')
+        .replace(/#.*$/, '')
+        .replace(/(\.schema)?\.json$/i, '');
+    const pascal = toPascalCase(file);
+    return pascal === '' ? 'Root' : pascal;
+}
+function isEnumLike(schema) {
+    return Array.isArray(schema.enum) || allConstMembers(schema) !== undefined;
+}
+/** The `{const, title}` members of a `oneOf`/`anyOf` that only lists constants (an enum spelled with labels). */
+function allConstMembers(schema) {
+    for (const keyword of ['oneOf', 'anyOf']) {
+        const members = schema[keyword];
+        if (Array.isArray(members) &&
+            members.length > 0 &&
+            members.every((member) => asRecord(member) !== undefined &&
+                Object.hasOwn(member, 'const'))) {
+            return members;
+        }
+    }
+    return undefined;
+}
+/** The schemas of a document that may be models: the root and every named schema. */
+function candidateSchemas(doc) {
+    const candidates = [];
+    if (!doc.isOpenApi) {
+        candidates.push({ doc, pointer: '#', schema: doc.root });
+    }
+    for (const collection of DEFINITION_COLLECTIONS) {
+        const navigated = navigate(doc, [...collection]);
+        const entries = navigated.found
+            ? asRecord(navigated.value)
+            : undefined;
+        if (entries === undefined) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(entries)) {
+            const schema = asRecord(value);
+            if (schema !== undefined) {
+                candidates.push({
+                    doc,
+                    pointer: pointerOf([...collection, key]),
+                    schema,
+                });
+            }
+        }
+    }
+    return candidates;
+}
+/** A oneOf/anyOf whose alternatives are references (a polymorphic type), apart from a null alternative. */
+function isUnionOfReferences(schema) {
+    for (const keyword of ['oneOf', 'anyOf']) {
+        const members = schema[keyword];
+        if (Array.isArray(members)) {
+            const references = members.filter((member) => asString(asRecord(member)?.$ref) !== undefined).length;
+            if (references >= 2) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function looksLikeObject(schema) {
+    return (schema.type === 'object' ||
+        (Array.isArray(schema.type) && schema.type.includes('object')) ||
+        schema.properties !== undefined ||
+        Array.isArray(schema.allOf));
+}
+function discoverModels(docs, ctx) {
+    const pending = [];
+    // Pass 1 registers every candidate, so that allOf parents (in any file) are recognised as models.
+    for (const doc of docs) {
+        for (const located of candidateSchemas(doc)) {
+            if (isEnumLike(located.schema)) {
+                continue;
+            }
+            const name = located.pointer === '#'
+                ? rootModelName(doc)
+                : sanitizeModelName(lastSegment(located.pointer));
+            if (!looksLikeObject(located.schema)) {
+                if (located.pointer !== '#' && isUnionOfReferences(located.schema)) {
+                    ctx.warnings.push(`${name}: a oneOf/anyOf schema has no database meaning, so it was not converted to a model.`);
+                }
+                continue;
+            }
+            const shape = collectShape(located.schema, doc, ctx, new Set(), 0);
+            if (shape.properties.size === 0) {
+                if (located.pointer !== '#' &&
+                    (shape.hasUnion || located.schema.discriminator !== undefined)) {
+                    ctx.warnings.push(`${name}: a oneOf/anyOf schema has no database meaning, so it was not converted to a model.`);
+                }
+                continue;
+            }
+            pending.push({ located, name, shape });
+            ctx.modelsByKey.set(locationKey(located), {
+                name,
+                key: locationKey(located),
+                doc,
+                schema: located.schema,
+                shape,
+            });
+        }
+    }
+    // Pass 2 settles the names and re-reads the shapes now that the parents are known.
+    const found = [];
+    const takenNames = new Set();
+    for (const entry of pending) {
+        let name = entry.name;
+        if (takenNames.has(name)) {
+            let counter = 2;
+            while (takenNames.has(`${entry.name}${counter}`)) {
+                counter += 1;
+            }
+            name = `${entry.name}${counter}`;
+            ctx.warnings.push(`${name}: the model name "${entry.name}" is already used by another schema, so this one (${entry.located.doc.path}${entry.located.pointer}) was renamed.`);
+        }
+        takenNames.add(name);
+        const key = locationKey(entry.located);
+        const info = {
+            name,
+            key,
+            doc: entry.located.doc,
+            schema: entry.located.schema,
+            shape: entry.shape,
+        };
+        ctx.modelsByKey.set(key, info);
+        found.push(info);
+    }
+    for (const info of found) {
+        info.shape = collectShape(info.schema, info.doc, ctx, new Set(), 0);
+    }
+    return found;
+}
+function registerEnumDefinitions(doc, ctx) {
+    for (const collection of DEFINITION_COLLECTIONS) {
+        const navigated = navigate(doc, [...collection]);
+        const entries = navigated.found
+            ? asRecord(navigated.value)
+            : undefined;
+        if (entries === undefined) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(entries)) {
+            const schema = asRecord(value);
+            if (schema === undefined || !isEnumLike(schema)) {
+                continue;
+            }
+            const pointer = pointerOf([...collection, key]);
+            const described = {
+                schema,
+                doc,
+                defName: key,
+                defKey: `${doc.fileUri}${pointer}`,
+                nullable: false,
+            };
+            enumFor(ctx, described, `${sanitizeModelName(key)}`, key, undefined);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Enums
+// ---------------------------------------------------------------------------
+function enumMemberName(value, index) {
+    const words = splitWords(value);
+    if (words.length === 0) {
+        return value === '' ? 'EMPTY' : `VALUE_${index + 1}`;
+    }
+    const name = words
+        .map((word) => word.toUpperCase())
+        .join('_');
+    return /^[0-9]/.test(name) ? `_${name}` : name;
+}
+/** Reads the string members of an enum schema, or undefined when it is not a string enum. */
+function readEnumValues(schema) {
+    const constMembers = allConstMembers(schema);
+    let raw;
+    let labels = [];
+    if (Array.isArray(schema.enum)) {
+        raw = schema.enum;
+    }
+    else if (constMembers !== undefined) {
+        raw = constMembers.map((member) => member.const);
+        labels = constMembers.map((member) => asString(member.title));
+    }
+    else {
+        return undefined;
+    }
+    const hasNull = raw.includes(null);
+    const strings = raw.filter((value) => value !== null);
+    if (strings.length === 0 ||
+        !strings.every((value) => typeof value === 'string')) {
+        return undefined;
+    }
+    const varNames = schema['x-enum-varnames'] ??
+        schema['x-enumNames'] ??
+        schema['x-enum-names'];
+    const seen = new Set();
+    const values = [];
+    strings.forEach((value, index) => {
+        if (values.some((existing) => existing.dbValue === value)) {
+            return;
+        }
+        const given = Array.isArray(varNames)
+            ? varNames[index]
+            : undefined;
+        let name = typeof given === 'string' && given !== ''
+            ? given
+            : enumMemberName(value, index);
+        while (seen.has(name)) {
+            name = `${name}_${index + 1}`;
+        }
+        seen.add(name);
+        const label = labels[index];
+        values.push({
+            name,
+            dbValue: value,
+            ...(label === undefined ? {} : { label }),
+        });
+    });
+    return { values, hasNull };
+}
+/**
+ * Returns the IR enum for an enum schema, creating it on first use. `preferred` is the name to try first
+ * (the `$defs` entry or the property); `modelName` disambiguates a clash.
+ */
+function enumFor(ctx, described, preferred, location, modelName) {
+    const read = readEnumValues(described.schema);
+    if (read === undefined) {
+        return undefined;
+    }
+    if (described.defKey !== undefined) {
+        const known = ctx.enumNameByKey.get(described.defKey);
+        if (known !== undefined) {
+            return known;
+        }
+    }
+    const sameValues = (other) => other.values.length === read.values.length &&
+        other.values.every((value, index) => value.dbValue === read.values[index]?.dbValue);
+    const base = sanitizeModelName(described.defName === undefined
+        ? toPascalCase(preferred) || preferred
+        : preferred);
+    const candidates = [
+        base,
+        ...(modelName === undefined ? [] : [`${modelName}${toPascalCase(base)}`]),
+    ];
+    let chosen;
+    for (const candidate of candidates) {
+        const existing = ctx.enums.get(candidate);
+        if (existing === undefined ||
+            (described.defKey === undefined && sameValues(existing))) {
+            chosen = candidate;
+            break;
+        }
+    }
+    if (chosen === undefined) {
+        let counter = 2;
+        const stem = candidates[candidates.length - 1] ?? base;
+        while (ctx.enums.has(`${stem}${counter}`)) {
+            counter += 1;
+        }
+        chosen = `${stem}${counter}`;
+        ctx.warnings.push(`${location}: the enum name "${base}" is already used with different values, so this enum was named "${chosen}".`);
+    }
+    if (!ctx.enums.has(chosen)) {
+        ctx.enums.set(chosen, { name: chosen, values: read.values });
+    }
+    if (described.defKey !== undefined) {
+        ctx.enumNameByKey.set(described.defKey, chosen);
+    }
+    return chosen;
+}
+// ---------------------------------------------------------------------------
+// Describing a property schema
+// ---------------------------------------------------------------------------
+/** Merges `allOf` members of a schema that is not a model into one schema (first `$ref` wins). */
+function flattenAllOf(schema, depth) {
+    if (!Array.isArray(schema.allOf) || depth > MAX_DEPTH) {
+        return schema;
+    }
+    const { allOf, ...rest } = schema;
+    let merged = {};
+    for (const member of allOf) {
+        const record = asRecord(member);
+        if (record === undefined) {
+            continue;
+        }
+        const flat = flattenAllOf(record, depth + 1);
+        const others = omitKey(flat, '$ref');
+        merged = {
+            ...merged,
+            ...others,
+            ...(merged.$ref === undefined && flat.$ref !== undefined
+                ? { $ref: flat.$ref }
+                : {}),
+        };
+    }
+    return { ...merged, ...rest };
+}
+function describeSchema(ctx, schemaValue, startDoc, location) {
+    let current = asRecordOrEmpty(schemaValue);
+    let doc = startDoc;
+    let nullable = false;
+    let defName;
+    let defKey;
+    const visited = new Set();
+    for (let step = 0; step <= MAX_DEPTH; step += 1) {
+        current = flattenAllOf(current, 0);
+        if (current.nullable === true) {
+            nullable = true;
+        }
+        // `anyOf`/`oneOf` of one schema and null is how nullable references are written.
+        for (const keyword of ['anyOf', 'oneOf']) {
+            const members = current[keyword];
+            if (!Array.isArray(members)) {
+                continue;
+            }
+            const nonNull = members.filter((member) => asRecord(member)?.type !== 'null');
+            if (nonNull.length === 1 && nonNull.length < members.length) {
+                current = {
+                    ...omitKey(current, keyword),
+                    ...asRecordOrEmpty(nonNull[0]),
+                };
+                nullable = true;
+            }
+        }
+        const ref = asString(current.$ref);
+        if (ref === undefined) {
+            return { schema: current, doc, defName, defKey, nullable };
+        }
+        const resolved = resolveRef(ctx, ref, doc);
+        if (!resolved.ok) {
+            return {
+                schema: {},
+                doc,
+                nullable,
+                failure: `${location}: ${resolved.reason}; the property was kept as a json column.`,
+            };
+        }
+        const key = locationKey(resolved.located);
+        const model = ctx.modelsByKey.get(key);
+        if (model !== undefined) {
+            return { model, schema: current, doc, nullable };
+        }
+        if (visited.has(key)) {
+            return {
+                schema: {},
+                doc,
+                nullable,
+                failure: `${location}: the reference "${ref}" is part of a reference cycle that never reaches an object schema; the property was kept as a json column.`,
+            };
+        }
+        visited.add(key);
+        current = { ...resolved.located.schema, ...omitKey(current, '$ref') };
+        doc = resolved.located.doc;
+        defName = lastSegment(resolved.located.pointer);
+        defKey = key;
+    }
+    return {
+        schema: {},
+        doc,
+        nullable,
+        failure: `${location}: references are nested more than ${MAX_DEPTH} levels deep; the property was kept as a json column.`,
+    };
+}
+/**
+ * Integers and decimals travel as strings in JSON so no precision is lost; the pattern says which.
+ * Reads `^-?[0-9]+$` (bigInt), `^-?[0-9]+(\.[0-9]+)?$` (decimal) and the same with a digit limit
+ * (`^-?[0-9]{1,6}(\.[0-9]{1,2})?$` is decimal(8, 2)), which is how ormbridge's own JSON Schema
+ * emitter writes them.
+ */
+function numericPattern(pattern) {
+    if (pattern === undefined) {
+        return undefined;
+    }
+    if (pattern === '^-?[0-9]+$') {
+        return { type: 'bigInt' };
+    }
+    if (pattern === '^-?[0-9]+(\\.[0-9]+)?$') {
+        return { type: 'decimal' };
+    }
+    const limited = /^\^-\?(?:\[0-9\]\{1,(\d+)\}|0\?)(?:\(\\\.\[0-9\]\{1,(\d+)\}\)\?)?\$$/.exec(pattern);
+    if (limited === null) {
+        return undefined;
+    }
+    const whole = Number(limited[1] ?? '0');
+    const places = Number(limited[2] ?? '0');
+    return { type: 'decimal', maxDigits: whole + places, decimalPlaces: places };
+}
+/** Maps a scalar `type`/`format` pair to an IR type. */
+function scalarType(type, schema) {
+    const format = asString(schema.format) ?? '';
+    if (type === 'string' &&
+        (schema.contentEncoding === 'base64' ||
+            format === 'byte' ||
+            format === 'binary')) {
+        return { type: 'bytes' };
+    }
+    if (type === 'string' && schema.contentMediaType === 'application/json') {
+        return { type: 'json' };
+    }
+    const patterned = type === 'string' ? numericPattern(asString(schema.pattern)) : undefined;
+    if (patterned !== undefined && format === '') {
+        return patterned;
+    }
+    if (format === 'decimal' || format === 'money') {
+        const precision = asNumber(schema['x-precision']);
+        const scale = asNumber(schema['x-scale']);
+        const multiple = asNumber(schema.multipleOf);
+        const derivedScale = multiple !== undefined && multiple > 0 && multiple < 1
+            ? Math.max(0, Math.round(-Math.log10(multiple)))
+            : undefined;
+        return {
+            type: 'decimal',
+            ...(precision === undefined ? {} : { maxDigits: precision }),
+            ...(scale !== undefined
+                ? { decimalPlaces: scale }
+                : derivedScale === undefined
+                    ? {}
+                    : { decimalPlaces: derivedScale }),
+        };
+    }
+    switch (type) {
+        case 'string':
+            switch (format) {
+                case 'date-time':
+                    return { type: 'dateTime' };
+                case 'date':
+                    return { type: 'date' };
+                case 'time':
+                    return { type: 'time' };
+                case 'uuid':
+                    return { type: 'uuid' };
+                case 'duration':
+                    return { type: 'duration' };
+                case 'ipv4':
+                case 'ipv6':
+                    return { type: 'ipAddress' };
+                case '':
+                    // A string with no length limit is unbounded text.
+                    return { type: schema.maxLength === undefined ? 'text' : 'string' };
+                default:
+                    return { type: 'string' };
+            }
+        case 'integer':
+            return {
+                type: format === 'int64' || format === 'uint64' || format === 'unix-time'
+                    ? 'bigInt'
+                    : 'int',
+            };
+        case 'number':
+            return {
+                type: format === 'int32' ? 'int' : format === 'int64' ? 'bigInt' : 'float',
+            };
+        case 'boolean':
+            return { type: 'boolean' };
+        default:
+            return { type: 'json' };
+    }
+}
+/** Works out the column type of a described schema (never a model). */
+function scalarOf(ctx, described, location, modelName, propertyName, depth) {
+    const schema = described.schema;
+    if (described.failure !== undefined) {
+        ctx.warnings.push(described.failure);
+        return { type: 'json' };
+    }
+    const read = readEnumValues(schema);
+    if (read !== undefined) {
+        const name = enumFor(ctx, described, described.defName ?? propertyName, location, modelName);
+        if (name !== undefined) {
+            const maxLength = asNumber(schema.maxLength);
+            return {
+                type: 'string',
+                enumName: name,
+                ...(maxLength === undefined ? {} : { maxLength }),
+            };
+        }
+    }
+    if (Array.isArray(schema.enum) || allConstMembers(schema) !== undefined) {
+        ctx.warnings.push(`${location}: only enums of strings are supported, so the allowed values were dropped and the column keeps its plain type.`);
+    }
+    const oneOf = schema.oneOf ?? schema.anyOf;
+    if (Array.isArray(oneOf) && allConstMembers(schema) === undefined) {
+        ctx.warnings.push(`${location}: a oneOf/anyOf union has no database meaning, so the property was kept as a json column.`);
+        return { type: 'json' };
+    }
+    const rawType = schema.type;
+    let type;
+    if (Array.isArray(rawType)) {
+        const kinds = rawType.filter((kind) => typeof kind === 'string' && kind !== 'null');
+        if (kinds.length === 1) {
+            type = kinds[0];
+        }
+        else if (kinds.length > 1) {
+            ctx.warnings.push(`${location}: the type union ${JSON.stringify(rawType)} has no database meaning, so the property was kept as a json column.`);
+            return { type: 'json' };
+        }
+    }
+    else if (typeof rawType === 'string') {
+        type = rawType;
+    }
+    if (type === undefined) {
+        if (schema.properties !== undefined) {
+            type = 'object';
+        }
+        else if (schema.items !== undefined || schema.prefixItems !== undefined) {
+            type = 'array';
+        }
+        else if (Object.hasOwn(schema, 'const')) {
+            const constant = schema.const;
+            type =
+                typeof constant === 'string'
+                    ? 'string'
+                    : typeof constant === 'number'
+                        ? Number.isInteger(constant)
+                            ? 'integer'
+                            : 'number'
+                        : typeof constant === 'boolean'
+                            ? 'boolean'
+                            : undefined;
+        }
+    }
+    if (type === 'array') {
+        return arrayOf(ctx, schema, described, location, modelName, propertyName, depth);
+    }
+    if (type === 'object') {
+        if (asRecord(schema.patternProperties) !== undefined) {
+            ctx.warnings.push(`${location}: patternProperties has no database meaning; the object was stored as a json column.`);
+        }
+        else if (asRecord(schema.additionalProperties) !== undefined) {
+            ctx.warnings.push(`${location}: an object used as a map (additionalProperties) has no database meaning; it was stored as a json column.`);
+        }
+        else if (schema.properties !== undefined) {
+            ctx.warnings.push(`${location}: a nested inline object was stored as a json column; its properties are not modelled. Define it under $defs to make it a model.`);
+        }
+        return { type: 'json' };
+    }
+    if (type === undefined) {
+        return { type: 'json' };
+    }
+    const mapped = scalarType(type, schema);
+    const maxLength = asNumber(schema.maxLength);
+    return {
+        ...mapped,
+        ...(maxLength !== undefined && mapped.type === 'string'
+            ? { maxLength }
+            : {}),
+    };
+}
+function arrayOf(ctx, schema, described, location, modelName, propertyName, depth) {
+    if (depth >= MAX_DEPTH || asRecord(schema.items) === undefined) {
+        ctx.warnings.push(`${location}: an array without a single item schema was stored as a json column.`);
+        return { type: 'json' };
+    }
+    const element = describeSchema(ctx, schema.items, described.doc, location);
+    if (element.model !== undefined) {
+        ctx.warnings.push(`${location}: arrays of models are only supported as a relation property; here the array was stored as a json column.`);
+        return { type: 'json' };
+    }
+    const inner = scalarOf(ctx, element, location, modelName, propertyName, depth + 1);
+    if (inner.type === 'json' && inner.arrayDepth === undefined) {
+        return { type: 'json' };
+    }
+    return { ...inner, arrayDepth: (inner.arrayDepth ?? 0) + 1 };
+}
+// ---------------------------------------------------------------------------
+// Building models
+// ---------------------------------------------------------------------------
+function toOnDelete(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    switch (value.toLowerCase().replace(/[\s_-]+/g, '')) {
+        case 'cascade':
+            return 'cascade';
+        case 'setnull':
+            return 'setNull';
+        case 'restrict':
+            return 'restrict';
+        case 'noaction':
+            return 'noAction';
+        case 'setdefault':
+            return 'setDefault';
+        default:
+            return undefined;
+    }
+}
+function buildDefault(field, schema, location, ctx) {
+    if (!Object.hasOwn(schema, 'default')) {
+        return undefined;
+    }
+    const value = schema.default;
+    if (value === null) {
+        return undefined;
+    }
+    if (field.arrayDepth !== undefined) {
+        ctx.warnings.push(`${location}: the default of an array column was ignored.`);
+        return undefined;
+    }
+    if (field.enumName !== undefined && typeof value === 'string') {
+        const member = ctx.enums
+            .get(field.enumName)
+            ?.values.find((candidate) => candidate.dbValue === value);
+        if (member === undefined) {
+            ctx.warnings.push(`${location}: the default "${value}" is not a member of the enum "${field.enumName}" and was ignored.`);
+            return undefined;
+        }
+        return { kind: 'enumValue', value: member.name };
+    }
+    if (field.type === 'json') {
+        return { kind: 'literal', value: JSON.stringify(value) };
+    }
+    if (field.type === 'dateTime' &&
+        typeof value === 'string' &&
+        /^(now|now\(\)|current_timestamp(\(\))?)$/i.test(value)) {
+        return { kind: 'now' };
+    }
+    if (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return { kind: 'literal', value };
+    }
+    ctx.warnings.push(`${location}: the default ${JSON.stringify(value)} cannot be stored as a column default and was ignored.`);
+    return undefined;
+}
+function isIdLike(name, modelName) {
+    const normalized = name.toLowerCase().replace(/_/g, '');
+    return (name === 'id' ||
+        normalized === `${modelName.toLowerCase().replace(/_/g, '')}id`);
+}
+function buildModel(info, ctx) {
+    const shape = info.shape;
+    const built = {
+        info,
+        fields: [],
+        toOne: [],
+        toMany: [],
+        relations: [],
+        indexes: [],
+    };
+    if (shape.inherited.length > 0) {
+        ctx.warnings.push(`${info.name}: allOf composition was flattened; the properties of ${shape.inherited.join(', ')} were copied into the model and the inheritance is not represented.`);
+    }
+    if (shape.hasUnion) {
+        ctx.warnings.push(`${info.name}: oneOf/anyOf has no database meaning and was ignored.`);
+    }
+    if (shape.hasPatternProperties) {
+        ctx.warnings.push(`${info.name}: patternProperties has no database meaning and was ignored.`);
+    }
+    if (shape.hasAdditionalSchema) {
+        ctx.warnings.push(`${info.name}: additionalProperties with a schema (a map) has no database meaning and was ignored.`);
+    }
+    if (shape.hasConditional) {
+        ctx.warnings.push(`${info.name}: if/then/else has no database meaning and was ignored.`);
+    }
+    const primaryMarked = [];
+    const readOnlyNames = new Set();
+    for (const [name, member] of shape.properties) {
+        const location = `${info.name}.${name}`;
+        const propertySchema = asRecordOrEmpty(member.schema);
+        const required = shape.required.has(name);
+        const described = describeSchema(ctx, member.schema, member.doc, location);
+        if (described.model !== undefined) {
+            const nullable = described.nullable || !required;
+            const relatedName = asString(propertySchema['x-related-name']) ??
+                asString(described.schema['x-related-name']);
+            const onDelete = toOnDelete(propertySchema['x-on-delete'] ?? described.schema['x-on-delete']);
+            built.toOne.push({
+                name,
+                target: described.model,
+                nullable,
+                required,
+                paired: false,
+                ...(onDelete === undefined ? {} : { onDelete }),
+                ...(relatedName === undefined ? {} : { relatedName }),
+            });
+            continue;
+        }
+        // An array of models is the to-many side of a relation.
+        if (described.failure === undefined &&
+            described.schema.type === 'array' &&
+            asRecord(described.schema.items) !== undefined) {
+            const element = describeSchema(ctx, described.schema.items, described.doc, location);
+            if (element.model !== undefined) {
+                built.toMany.push({ name, target: element.model, paired: false });
+                continue;
+            }
+        }
+        const scalar = scalarOf(ctx, described, location, info.name, name, 0);
+        const merged = { ...described.schema, ...propertySchema };
+        // Null is allowed by the type; an optional property without a default or a generated value is
+        // nullable too (the column may stay empty).
+        const allowsNull = described.nullable ||
+            (Array.isArray(merged.type) && merged.type.includes('null')) ||
+            (Array.isArray(merged.enum) && merged.enum.includes(null));
+        const field = {
+            name,
+            columnName: name,
+            type: scalar.type,
+            isPrimaryKey: false,
+            isUnique: merged['x-unique'] === true,
+            isNullable: allowsNull,
+            isAutoUpdated: false,
+            ...(scalar.maxLength === undefined
+                ? {}
+                : { maxLength: scalar.maxLength }),
+            ...(scalar.maxDigits === undefined
+                ? {}
+                : { maxDigits: scalar.maxDigits }),
+            ...(scalar.decimalPlaces === undefined
+                ? {}
+                : { decimalPlaces: scalar.decimalPlaces }),
+            ...(scalar.enumName === undefined ? {} : { enumName: scalar.enumName }),
+            ...(scalar.arrayDepth === undefined
+                ? {}
+                : { arrayDepth: scalar.arrayDepth }),
+        };
+        const defaultValue = buildDefault(scalar, merged, location, ctx);
+        if (defaultValue !== undefined) {
+            field.default = defaultValue;
+        }
+        if (merged.readOnly === true && field.default === undefined) {
+            applyReadOnlyHint(field);
+        }
+        if (!required &&
+            merged.readOnly !== true &&
+            field.default === undefined &&
+            !Object.hasOwn(merged, 'default')) {
+            field.isNullable = true;
+        }
+        if (merged['x-primary-key'] === true) {
+            primaryMarked.push(name);
+        }
+        if (merged['x-index'] === true) {
+            built.indexes.push({ fields: [name], isUnique: false });
+        }
+        if (merged.readOnly === true) {
+            readOnlyNames.add(name);
+        }
+        built.fields.push(field);
+    }
+    // Foreign key columns declared next to the relation (authorId, author_id) become the relation's column.
+    for (const relation of built.toOne) {
+        const wanted = relation.name.toLowerCase().replace(/_/g, '');
+        const column = built.fields.find((field) => field.name.toLowerCase().replace(/_/g, '') === `${wanted}id` &&
+            ['int', 'bigInt', 'uuid', 'string', 'text'].includes(field.type) &&
+            field.arrayDepth === undefined &&
+            !primaryMarked.includes(field.name));
+        if (column !== undefined) {
+            relation.fkColumn = column.name;
+            // The column holds the key, so its nullability is the relation's (the property that expands
+            // the reference is usually optional whatever the column says).
+            relation.nullable = column.isNullable;
+            relation.required = !column.isNullable;
+            built.fields.splice(built.fields.indexOf(column), 1);
+        }
+    }
+    assignPrimaryKey(built, primaryMarked, readOnlyNames, info, ctx);
+    const modelIndexes = info.schema['x-indexes'];
+    if (Array.isArray(modelIndexes)) {
+        for (const entry of modelIndexes) {
+            const record = asRecord(entry);
+            const fields = record?.fields;
+            if (record === undefined ||
+                !Array.isArray(fields) ||
+                fields.length === 0 ||
+                !fields.every((item) => typeof item === 'string')) {
+                ctx.warnings.push(`${info.name}: an x-indexes entry without a "fields" array of property names was ignored.`);
+                continue;
+            }
+            const name = asString(record.name);
+            built.indexes.push({
+                fields: fields,
+                isUnique: record.unique === true,
+                ...(name === undefined ? {} : { name }),
+            });
+        }
+    }
+    return built;
+}
+/** `readOnly` marks a value the database produces: keys count up, uuids are generated, timestamps are set. */
+function applyReadOnlyHint(field) {
+    if (field.type === 'uuid') {
+        field.default = { kind: 'uuid' };
+    }
+    else if (field.type === 'dateTime') {
+        if (/^updated/i.test(field.name.replace(/_/g, ''))) {
+            field.isAutoUpdated = true;
+        }
+        else {
+            field.default = { kind: 'now' };
+        }
+    }
+}
+function assignPrimaryKey(built, marked, readOnlyNames, info, ctx) {
+    const fieldNamed = (name) => built.fields.find((field) => field.name === name);
+    let keyNames = marked;
+    const modelLevel = info.schema['x-primary-key'];
+    if (keyNames.length === 0 && Array.isArray(modelLevel)) {
+        keyNames = modelLevel.filter((name) => typeof name === 'string' && fieldNamed(name) !== undefined);
+    }
+    if (keyNames.length === 0) {
+        const candidate = fieldNamed('id') ??
+            built.fields.find((field) => isIdLike(field.name, info.name));
+        const usable = [
+            'int',
+            'bigInt',
+            'string',
+            'text',
+            'uuid',
+            'decimal',
+        ];
+        if (candidate !== undefined &&
+            usable.includes(candidate.type) &&
+            candidate.arrayDepth === undefined) {
+            keyNames = [candidate.name];
+        }
+    }
+    if (keyNames.length === 0) {
+        const takenId = built.fields.some((field) => field.name === 'id');
+        const name = takenId ? 'ormbridge_id' : 'id';
+        ctx.warnings.push(`${info.name}: no primary key property was found (an id, ${info.name.charAt(0).toLowerCase()}${info.name.slice(1)}Id or x-primary-key property), so an integer "${name}" column was added.`);
+        built.fields.unshift({
+            name,
+            columnName: name,
+            type: 'int',
+            isPrimaryKey: true,
+            isUnique: false,
+            isNullable: false,
+            isAutoUpdated: false,
+            default: { kind: 'autoIncrement' },
+        });
+        return;
+    }
+    if (keyNames.length > 1) {
+        built.compositePrimaryKey = keyNames;
+        for (const name of keyNames) {
+            const field = fieldNamed(name);
+            if (field !== undefined) {
+                field.isNullable = false;
+            }
+        }
+        return;
+    }
+    const keyField = fieldNamed(keyNames[0] ?? '');
+    if (keyField === undefined) {
+        return;
+    }
+    keyField.isPrimaryKey = true;
+    keyField.isNullable = false;
+    keyField.isUnique = false;
+    if (keyField.default === undefined && readOnlyNames.has(keyField.name)) {
+        if (keyField.type === 'int' || keyField.type === 'bigInt') {
+            keyField.default = { kind: 'autoIncrement' };
+        }
+        else if (keyField.type === 'uuid') {
+            keyField.default = { kind: 'uuid' };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Relations
+// ---------------------------------------------------------------------------
+function relationColumn(name, fk) {
+    if (fk !== undefined) {
+        return fk;
+    }
+    return `${toSnakeCase(name)}_id`;
+}
+function defaultOnDelete(prop) {
+    return prop.onDelete ?? (prop.nullable ? 'setNull' : 'restrict');
+}
+function pairRelations(built, ctx) {
+    const byInfo = new Map(built.map((model) => [model.info, model]));
+    // To-one properties that point at each other are the two sides of a one-to-one relation.
+    for (const model of built) {
+        for (const prop of model.toOne) {
+            if (prop.paired) {
+                continue;
+            }
+            const other = byInfo.get(prop.target);
+            if (other !== undefined && hasArrayBack(model, prop, other)) {
+                continue;
+            }
+            const reverse = other?.toOne.filter((candidate) => !candidate.paired &&
+                candidate !== prop &&
+                candidate.target === model.info &&
+                !hasArrayBack(other, candidate, model) &&
+                (candidate.relatedName === prop.name ||
+                    candidate.relatedName === undefined) &&
+                (prop.relatedName === candidate.name ||
+                    prop.relatedName === undefined)) ?? [];
+            const sameFirst = reverse.filter((candidate) => prop.relatedName === candidate.name ||
+                candidate.relatedName === prop.name);
+            const chosen = sameFirst.length > 0 ? sameFirst : reverse;
+            const sibling = chosen[0];
+            if (other === undefined || sibling === undefined || chosen.length !== 1) {
+                continue;
+            }
+            // The required side holds the foreign key; otherwise the model defined later does.
+            const siblingOwns = sibling.required !== prop.required
+                ? sibling.required
+                : built.indexOf(other) > built.indexOf(model);
+            if (sibling.required === prop.required) {
+                ctx.warnings.push(`${model.info.name}.${prop.name} and ${other.info.name}.${sibling.name} reference each other and are read as one one-to-one relation owned by ${siblingOwns ? other.info.name : model.info.name}; mark the owning side as required to choose the direction.`);
+            }
+            const owner = siblingOwns ? sibling : prop;
+            const inverse = siblingOwns ? prop : sibling;
+            prop.paired = true;
+            sibling.paired = true;
+            const ownerModel = siblingOwns ? other : model;
+            ownerModel.relations.push({
+                name: owner.name,
+                kind: 'oneToOne',
+                targetModel: owner.target.name,
+                columnName: relationColumn(owner.name, owner.fkColumn),
+                isNullable: owner.nullable,
+                onDelete: defaultOnDelete(owner),
+                relatedName: inverse.name,
+            });
+        }
+    }
+    // An array of models is the reverse of the foreign key on the other model, or a many-to-many when both sides are arrays.
+    for (const model of built) {
+        for (const many of model.toMany) {
+            if (many.paired) {
+                continue;
+            }
+            const other = byInfo.get(many.target);
+            if (other === undefined) {
+                continue;
+            }
+            const foreignKeys = other.toOne.filter((candidate) => !candidate.paired && candidate.target === model.info);
+            const named = foreignKeys.filter((candidate) => candidate.relatedName === many.name);
+            const foreignKey = named[0] ?? (foreignKeys.length === 1 ? foreignKeys[0] : undefined);
+            if (foreignKey !== undefined) {
+                many.paired = true;
+                foreignKey.paired = true;
+                other.relations.push({
+                    name: foreignKey.name,
+                    kind: 'foreignKey',
+                    targetModel: model.info.name,
+                    columnName: relationColumn(foreignKey.name, foreignKey.fkColumn),
+                    isNullable: foreignKey.nullable,
+                    onDelete: defaultOnDelete(foreignKey),
+                    relatedName: many.name,
+                });
+                continue;
+            }
+            const unnamed = foreignKeys.filter((candidate) => candidate.relatedName === undefined);
+            const arrays = model.toMany.filter((candidate) => !candidate.paired && candidate.target === many.target);
+            const byPosition = arrays.length === unnamed.length
+                ? unnamed[arrays.indexOf(many)]
+                : undefined;
+            if (byPosition !== undefined) {
+                many.paired = true;
+                byPosition.paired = true;
+                ctx.warnings.push(`${model.info.name}.${many.name}: ${other.info.name} has ${unnamed.length} properties that reference ${model.info.name} (${unnamed.map((candidate) => candidate.name).join(', ')}) and ${model.info.name} has as many arrays of ${other.info.name}, so they were matched in order of appearance and this array is the reverse of ${other.info.name}.${byPosition.name}. Set "x-related-name": "${many.name}" on the right property to say so explicitly.`);
+                other.relations.push({
+                    name: byPosition.name,
+                    kind: 'foreignKey',
+                    targetModel: model.info.name,
+                    columnName: relationColumn(byPosition.name, byPosition.fkColumn),
+                    isNullable: byPosition.nullable,
+                    onDelete: defaultOnDelete(byPosition),
+                    relatedName: many.name,
+                });
+                continue;
+            }
+            if (foreignKeys.length > 1) {
+                ctx.warnings.push(`${model.info.name}.${many.name}: ${other.info.name} has several properties that reference ${model.info.name} (${foreignKeys.map((candidate) => candidate.name).join(', ')}), so it is unclear which one this array is the reverse of. Set "x-related-name": "${many.name}" on the right one. The array was ignored.`);
+                many.paired = true;
+                continue;
+            }
+            const mirrors = other.toMany.filter((candidate) => !candidate.paired &&
+                candidate !== many &&
+                candidate.target === model.info);
+            if (mirrors.length === 1 && mirrors[0] !== undefined) {
+                const mirror = mirrors[0];
+                many.paired = true;
+                mirror.paired = true;
+                // The model defined first owns the many-to-many field.
+                const manyOwns = built.indexOf(model) <= built.indexOf(other);
+                const owner = manyOwns ? many : mirror;
+                const inverse = manyOwns ? mirror : many;
+                (manyOwns ? model : other).relations.push({
+                    name: owner.name,
+                    kind: 'manyToMany',
+                    targetModel: owner.target.name,
+                    columnName: `${toSnakeCase(owner.name)}_id`,
+                    isNullable: false,
+                    onDelete: 'cascade',
+                    relatedName: inverse.name,
+                });
+                continue;
+            }
+            if (mirrors.length > 1) {
+                ctx.warnings.push(`${model.info.name}.${many.name}: ${other.info.name} has several arrays of ${model.info.name}, so the many-to-many pairing is ambiguous and the array was ignored.`);
+                many.paired = true;
+                continue;
+            }
+            // Only one side is written down: the foreign key lives on the other model.
+            many.paired = true;
+            const reverseName = uniqueName(other, model.info.name.charAt(0).toLowerCase() + model.info.name.slice(1));
+            ctx.warnings.push(`${model.info.name}.${many.name}: ${other.info.name} does not reference ${model.info.name} back, so a nullable foreign key "${reverseName}" was added to ${other.info.name} to hold the relation (many-to-many needs an array on both sides).`);
+            other.relations.push({
+                name: reverseName,
+                kind: 'foreignKey',
+                targetModel: model.info.name,
+                columnName: relationColumn(reverseName, undefined),
+                isNullable: true,
+                onDelete: 'setNull',
+                relatedName: many.name,
+            });
+        }
+    }
+    // Remaining to-one properties are plain many-to-one foreign keys.
+    for (const model of built) {
+        for (const prop of model.toOne) {
+            if (prop.paired) {
+                continue;
+            }
+            prop.paired = true;
+            model.relations.push({
+                name: prop.name,
+                kind: 'foreignKey',
+                targetModel: prop.target.name,
+                columnName: relationColumn(prop.name, prop.fkColumn),
+                isNullable: prop.nullable,
+                onDelete: defaultOnDelete(prop),
+                ...(prop.relatedName === undefined
+                    ? {}
+                    : { relatedName: prop.relatedName }),
+            });
+        }
+    }
+}
+/** True when `target` lists an array of `owner`'s model that is the reverse of the to-one `prop` of `owner`. */
+function hasArrayBack(owner, prop, target) {
+    return target.toMany.some((many) => many.target === owner.info &&
+        (prop.relatedName === undefined || many.name === prop.relatedName));
+}
+function uniqueName(model, wanted) {
+    const taken = (name) => model.fields.some((field) => field.name === name) ||
+        model.relations.some((relation) => relation.name === name) ||
+        model.toOne.some((prop) => prop.name === name) ||
+        model.toMany.some((prop) => prop.name === name);
+    let name = wanted;
+    let counter = 2;
+    while (taken(name)) {
+        name = `${wanted}${counter}`;
+        counter += 1;
+    }
+    return name;
+}
+/** Relations in the order of the properties they came from (synthesized ones last). */
+function sortRelations(built) {
+    const order = [...built.info.shape.properties.keys()];
+    const position = (relation) => {
+        const index = order.indexOf(relation.name);
+        return index === -1 ? order.length : index;
+    };
+    return [...built.relations].sort((first, second) => position(first) - position(second));
+}
+function finishModel(built, ctx) {
+    const info = built.info;
+    const tableName = asString(info.schema['x-table-name']) ?? info.name;
+    const names = new Set([
+        ...built.fields.map((field) => field.name),
+        ...built.relations.map((relation) => relation.name),
+    ]);
+    const indexes = [];
+    for (const index of built.indexes) {
+        const unknown = index.fields.filter((name) => !names.has(name));
+        if (unknown.length > 0) {
+            ctx.warnings.push(`${info.name}: an index refers to ${unknown.join(', ')}, which ${unknown.length === 1 ? 'is' : 'are'} not ${unknown.length === 1 ? 'a property' : 'properties'} of the model, so it was ignored.`);
+            continue;
+        }
+        indexes.push(index);
+    }
+    return {
+        name: info.name,
+        tableName,
+        appLabel: ctx.options.appLabel,
+        fields: built.fields,
+        relations: sortRelations(built),
+        indexes,
+        ...(built.compositePrimaryKey === undefined
+            ? {}
+            : { compositePrimaryKey: built.compositePrimaryKey }),
+    };
+}
+//# sourceMappingURL=jsonSchema.js.map