ormbridge 0.0.0-stage → 0.3.0

package/dist/emitters/typeorm.js

@@ -0,0 +1,838 @@
+import { prismaOnlyWarnings } from '../prismaOnlyConstructs.js';
+import { findModel } from '../ir.js';
+import { toCamelCase, toSnakeCase } from '../naming.js';
+const IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const CREATED_FIELD_PATTERN = /^(created|created_?at|date_?created|createdon)$/i;
+const MAX_LINE_WIDTH = 80;
+const ON_DELETE_NAMES = {
+    cascade: 'CASCADE',
+    setNull: 'SET NULL',
+    restrict: 'RESTRICT',
+    noAction: 'NO ACTION',
+    setDefault: 'SET DEFAULT',
+};
+export function emitTypeorm(schema, options) {
+    const context = {
+        schema,
+        options,
+        dialect: dialectOf(options.provider),
+        warnings: prismaOnlyWarnings(schema),
+        imports: new Set(),
+        names: new Map(),
+        inverseNames: new Map(),
+    };
+    if (options.provider === 'mongodb') {
+        context.warnings.push('Provider "mongodb": TypeORM entities for MongoDB need different decorators; SQL column types (PostgreSQL style) were used.');
+    }
+    allocateNames(context);
+    const blocks = [];
+    for (const enumDefinition of schema.enums) {
+        blocks.push(emitEnum(context, enumDefinition));
+    }
+    const inverseMembers = new Map();
+    const classMembers = new Map();
+    for (const model of schema.models) {
+        classMembers.set(model.name, buildForwardMembers(context, model, inverseMembers));
+    }
+    for (const model of schema.models) {
+        const members = [
+            ...(classMembers.get(model.name) ?? []),
+            ...(inverseMembers.get(model.name) ?? []),
+        ];
+        blocks.push(emitClass(context, model, members));
+    }
+    if (blocks.length === 0) {
+        return { text: '', warnings: context.warnings };
+    }
+    const importLine = buildImportLine(context.imports);
+    return {
+        text: `${[importLine, ...blocks].join('\n\n')}\n`,
+        warnings: context.warnings,
+    };
+}
+// ---------------------------------------------------------------------------
+// Imports and small formatting helpers
+// ---------------------------------------------------------------------------
+function buildImportLine(imports) {
+    const names = [...imports].sort((first, second) => first.localeCompare(second));
+    const specifiers = names.map((name) => name === 'Relation' ? 'type Relation' : name);
+    return `import { ${specifiers.join(', ')} } from 'typeorm';`;
+}
+function use(context, name) {
+    context.imports.add(name);
+    return name;
+}
+function quote(value) {
+    const escaped = value.replace(/\\/g, '\\\\').replace(/\n/g, '\\n');
+    if (value.includes("'") && !value.includes('"')) {
+        return `"${escaped}"`;
+    }
+    return `'${escaped.replace(/'/g, "\\'")}'`;
+}
+/**
+ * Formats a decorator. Leading arguments are written as-is; options become one
+ * object literal that wraps onto several lines when the decorator is too wide.
+ */
+function decorator(name, args, entries, indent = '  ') {
+    const parts = [...args];
+    if (entries.length > 0) {
+        parts.push(`{ ${entries.join(', ')} }`);
+    }
+    const inline = `${indent}@${name}(${parts.join(', ')})`;
+    if (entries.length === 0 || inline.length <= MAX_LINE_WIDTH) {
+        return [inline];
+    }
+    const lead = args.length > 0 ? `${args.join(', ')}, ` : '';
+    return [
+        `${indent}@${name}(${lead}{`,
+        ...entries.map((entry) => `${indent}  ${entry},`),
+        `${indent}})`,
+    ];
+}
+function identifier(context, owner, raw) {
+    if (IDENTIFIER_PATTERN.test(raw)) {
+        return raw;
+    }
+    const replaced = raw.replace(/[^A-Za-z0-9_$]/g, '_');
+    const safe = /^[0-9]/.test(replaced) ? `_${replaced}` : replaced;
+    const result = safe === '' ? '_' : safe;
+    context.warnings.push(`${owner}: "${raw}" is not a valid TypeScript identifier; it was written as "${result}".`);
+    return result;
+}
+function uniqueName(baseName, used) {
+    let candidate = baseName;
+    let suffix = 2;
+    while (used.has(candidate)) {
+        candidate = `${baseName}${suffix}`;
+        suffix += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function dialectOf(provider) {
+    switch (provider) {
+        case 'mysql':
+            return 'mysql';
+        case 'sqlite':
+            return 'sqlite';
+        case 'sqlserver':
+            return 'sqlserver';
+        default:
+            return 'postgres';
+    }
+}
+// ---------------------------------------------------------------------------
+// Names
+// ---------------------------------------------------------------------------
+function propertyName(context, rawName) {
+    return context.options.camelFields ? toCamelCase(rawName) : rawName;
+}
+function isKeyedRelation(model, relation) {
+    return (relation.isPrimaryKey === true ||
+        (model.compositePrimaryKey?.includes(relation.name) ?? false));
+}
+function allocateNames(context) {
+    for (const model of context.schema.models) {
+        const names = {
+            fields: new Map(),
+            relations: new Map(),
+            scalars: new Map(),
+            used: new Set(),
+        };
+        for (const field of model.fields) {
+            const safe = identifier(context, `${model.name}.${field.name}`, propertyName(context, field.name));
+            names.fields.set(field.name, uniqueName(safe, names.used));
+        }
+        for (const relation of model.relations) {
+            const safe = identifier(context, `${model.name}.${relation.name}`, propertyName(context, relation.name));
+            const relationProp = uniqueName(safe, names.used);
+            names.relations.set(relation.name, relationProp);
+            if (relation.kind !== 'manyToMany' && isKeyedRelation(model, relation)) {
+                const columnProp = propertyName(context, relation.columnName);
+                const base = columnProp !== relationProp ? columnProp : `${relationProp}Id`;
+                names.scalars.set(relation.name, uniqueName(identifier(context, `${model.name}.${relation.name}`, base), names.used));
+            }
+        }
+        context.names.set(model.name, names);
+    }
+    for (const model of context.schema.models) {
+        for (const relation of model.relations) {
+            const target = findModel(context.schema, relation.targetModel);
+            const targetNames = context.names.get(relation.targetModel);
+            if (target === undefined || targetNames === undefined) {
+                continue;
+            }
+            const defaultName = relation.kind === 'oneToOne'
+                ? toSnakeCase(model.name)
+                : `${toSnakeCase(model.name)}_set`;
+            const safe = identifier(context, `${model.name}.${relation.name}`, propertyName(context, relation.relatedName ?? defaultName));
+            context.inverseNames.set(`${model.name}.${relation.name}`, uniqueName(safe, targetNames.used));
+        }
+    }
+}
+function namesOf(context, model) {
+    return (context.names.get(model.name) ?? {
+        fields: new Map(),
+        relations: new Map(),
+        scalars: new Map(),
+        used: new Set(),
+    });
+}
+// ---------------------------------------------------------------------------
+// Enums
+// ---------------------------------------------------------------------------
+function emitEnum(context, enumDefinition) {
+    const lines = [`export enum ${enumDefinition.name} {`];
+    for (const value of enumDefinition.values) {
+        lines.push(`  ${enumMemberName(context, enumDefinition, value)} = ${quote(value.dbValue)},`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+function enumMemberName(context, enumDefinition, value) {
+    return identifier(context, `enum ${enumDefinition.name}`, value.name);
+}
+/** Finds the enum member a default refers to, by member name or stored value. */
+function enumReference(context, enumDefinition, raw) {
+    const value = enumDefinition.values.find((candidate) => candidate.name === raw) ??
+        enumDefinition.values.find((candidate) => candidate.dbValue === raw);
+    if (value === undefined) {
+        return undefined;
+    }
+    const memberName = identifier({ ...context, warnings: [] }, '', value.name);
+    return `${enumDefinition.name}.${memberName}`;
+}
+// ---------------------------------------------------------------------------
+// Column types
+// ---------------------------------------------------------------------------
+const POSTGRES_RANGE_TYPES = {
+    int: 'int4range',
+    bigInt: 'int8range',
+    decimal: 'numrange',
+    date: 'daterange',
+    dateTime: 'tstzrange',
+};
+/** Column type of a field, including array columns built on top of the element type. */
+function columnSpecOf(context, label, field) {
+    const depth = field.arrayDepth ?? 0;
+    if (depth === 0) {
+        return scalarColumnSpec(context, label, field);
+    }
+    const element = scalarColumnSpec(context, label, {
+        ...field,
+        arrayDepth: undefined,
+    });
+    const tsType = `${element.tsType.includes(' ') ? `(${element.tsType})` : element.tsType}${'[]'.repeat(depth)}`;
+    if (context.dialect === 'postgres') {
+        return {
+            typeEntries: [...element.typeEntries, 'array: true'],
+            tsType,
+            dbType: element.dbType,
+        };
+    }
+    const jsonType = context.dialect === 'mysql' ? 'json' : 'simple-json';
+    context.warnings.push(`${label}: ${context.dialect} has no array column type; the array was written as ${jsonType}.`);
+    return {
+        typeEntries: [`type: '${jsonType}'`],
+        tsType,
+        dbType: jsonType,
+    };
+}
+function scalarColumnSpec(context, label, field) {
+    const dialect = context.dialect;
+    if (field.enumName !== undefined) {
+        const enumDefinition = context.schema.enums.find((candidate) => candidate.name === field.enumName);
+        if (enumDefinition === undefined) {
+            context.warnings.push(`${label}: enum "${field.enumName}" does not exist in the schema; the column is written as a plain string.`);
+        }
+        else if (dialect === 'sqlserver') {
+            context.warnings.push(`${label}: SQL Server has no enum column type; it was written as varchar and the TypeScript enum "${enumDefinition.name}" is only used for typing.`);
+            return {
+                typeEntries: [`type: 'varchar'`],
+                tsType: enumDefinition.name,
+                dbType: 'varchar',
+            };
+        }
+        else {
+            const enumType = dialect === 'sqlite' ? 'simple-enum' : 'enum';
+            return {
+                typeEntries: [
+                    `type: ${quote(enumType)}`,
+                    `enum: ${enumDefinition.name}`,
+                ],
+                tsType: enumDefinition.name,
+                dbType: enumType,
+            };
+        }
+    }
+    switch (field.type) {
+        case 'string': {
+            const entries = [`type: 'varchar'`];
+            if (field.maxLength !== undefined) {
+                entries.push(`length: ${field.maxLength}`);
+            }
+            return { typeEntries: entries, tsType: 'string', dbType: 'varchar' };
+        }
+        case 'text':
+            return {
+                typeEntries: [`type: 'text'`],
+                tsType: 'string',
+                dbType: 'text',
+            };
+        case 'uuid':
+            if (dialect === 'mysql' || dialect === 'sqlite') {
+                return {
+                    typeEntries: [`type: 'varchar'`, 'length: 36'],
+                    tsType: 'string',
+                    dbType: 'varchar',
+                };
+            }
+            return dialect === 'sqlserver'
+                ? {
+                    typeEntries: [`type: 'uniqueidentifier'`],
+                    tsType: 'string',
+                    dbType: 'uniqueidentifier',
+                }
+                : { typeEntries: [`type: 'uuid'`], tsType: 'string', dbType: 'uuid' };
+        case 'int':
+            return { typeEntries: [`type: 'int'`], tsType: 'number', dbType: 'int' };
+        case 'bigInt':
+            return {
+                typeEntries: [`type: 'bigint'`],
+                tsType: 'string',
+                dbType: 'bigint',
+            };
+        case 'float':
+            return {
+                typeEntries: [`type: 'float'`],
+                tsType: 'number',
+                dbType: 'float',
+            };
+        case 'decimal': {
+            const entries = [`type: 'decimal'`];
+            if (field.maxDigits !== undefined && field.decimalPlaces !== undefined) {
+                entries.push(`precision: ${field.maxDigits}`, `scale: ${field.decimalPlaces}`);
+            }
+            return { typeEntries: entries, tsType: 'string', dbType: 'decimal' };
+        }
+        case 'boolean': {
+            const booleanType = dialect === 'sqlserver' ? 'bit' : 'boolean';
+            return {
+                typeEntries: [`type: '${booleanType}'`],
+                tsType: 'boolean',
+                dbType: booleanType,
+            };
+        }
+        case 'dateTime': {
+            const dateTimeType = dialect === 'postgres'
+                ? 'timestamptz'
+                : dialect === 'sqlserver'
+                    ? 'datetimeoffset'
+                    : 'datetime';
+            return {
+                typeEntries: [`type: '${dateTimeType}'`],
+                tsType: 'Date',
+                dbType: dateTimeType,
+            };
+        }
+        case 'date':
+            return {
+                typeEntries: [`type: 'date'`],
+                tsType: 'string',
+                dbType: 'date',
+            };
+        case 'time':
+            return {
+                typeEntries: [`type: 'time'`],
+                tsType: 'string',
+                dbType: 'time',
+            };
+        case 'json': {
+            const jsonType = dialect === 'postgres'
+                ? 'jsonb'
+                : dialect === 'mysql'
+                    ? 'json'
+                    : 'simple-json';
+            return {
+                typeEntries: [`type: '${jsonType}'`],
+                tsType: 'unknown',
+                dbType: jsonType,
+            };
+        }
+        case 'bytes': {
+            const bytesType = dialect === 'postgres'
+                ? 'bytea'
+                : dialect === 'sqlserver'
+                    ? 'varbinary'
+                    : 'blob';
+            return {
+                typeEntries: [`type: '${bytesType}'`],
+                tsType: 'Buffer',
+                dbType: bytesType,
+            };
+        }
+        case 'duration':
+            if (dialect === 'postgres') {
+                return {
+                    typeEntries: [`type: 'interval'`],
+                    tsType: 'string',
+                    dbType: 'interval',
+                };
+            }
+            context.warnings.push(`${label}: ${dialect} has no interval type; the duration was written as bigint (microseconds).`);
+            return {
+                typeEntries: [`type: 'bigint'`],
+                tsType: 'string',
+                dbType: 'bigint',
+            };
+        case 'ipAddress':
+            if (dialect === 'postgres') {
+                return {
+                    typeEntries: [`type: 'inet'`],
+                    tsType: 'string',
+                    dbType: 'inet',
+                };
+            }
+            return {
+                typeEntries: [`type: 'varchar'`, 'length: 45'],
+                tsType: 'string',
+                dbType: 'varchar',
+            };
+        case 'hstore':
+            if (dialect === 'postgres') {
+                return {
+                    typeEntries: [`type: 'hstore'`],
+                    tsType: 'Record<string, string | null>',
+                    dbType: 'hstore',
+                };
+            }
+            context.warnings.push(`${label}: hstore exists only on PostgreSQL; the field was written as ${dialect === 'mysql' ? 'json' : 'simple-json'}.`);
+            return {
+                typeEntries: [
+                    `type: '${dialect === 'mysql' ? 'json' : 'simple-json'}'`,
+                ],
+                tsType: 'Record<string, string | null>',
+                dbType: dialect === 'mysql' ? 'json' : 'simple-json',
+            };
+        case 'range':
+            if (dialect === 'postgres') {
+                const rangeType = POSTGRES_RANGE_TYPES[field.rangeOf ?? 'int'] ?? 'int4range';
+                return {
+                    typeEntries: [`type: '${rangeType}'`],
+                    tsType: 'string',
+                    dbType: rangeType,
+                };
+            }
+            context.warnings.push(`${label}: range columns exist only on PostgreSQL; the field was written as varchar.`);
+            return {
+                typeEntries: [`type: 'varchar'`],
+                tsType: 'string',
+                dbType: 'varchar',
+            };
+        default:
+            context.warnings.push(`${label}: unknown field type "${String(field.type)}"; it was written as varchar.`);
+            return {
+                typeEntries: [`type: 'varchar'`],
+                tsType: 'string',
+                dbType: 'varchar',
+            };
+    }
+}
+/** Returns the `default:` option text for a field, or undefined when there is none. */
+function defaultEntryOf(context, label, field) {
+    const defaultValue = field.default;
+    if (defaultValue === undefined) {
+        return undefined;
+    }
+    const enumDefinition = field.enumName === undefined
+        ? undefined
+        : context.schema.enums.find((candidate) => candidate.name === field.enumName);
+    switch (defaultValue.kind) {
+        case 'autoIncrement':
+            context.warnings.push(`${label}: an auto-increment default is only supported on primary keys; it was dropped.`);
+            return undefined;
+        case 'now':
+            return `default: () => 'CURRENT_TIMESTAMP'`;
+        case 'uuid': {
+            const expression = context.dialect === 'postgres'
+                ? 'gen_random_uuid()'
+                : context.dialect === 'mysql'
+                    ? '(UUID())'
+                    : context.dialect === 'sqlserver'
+                        ? 'NEWID()'
+                        : undefined;
+            if (expression === undefined) {
+                context.warnings.push(`${label}: SQLite has no database-side UUID default; the default was dropped.`);
+                return undefined;
+            }
+            return `default: () => ${quote(expression)}`;
+        }
+        case 'enumValue': {
+            const reference = enumDefinition === undefined
+                ? undefined
+                : enumReference(context, enumDefinition, defaultValue.value);
+            if (reference === undefined) {
+                context.warnings.push(`${label}: the enum default "${defaultValue.value}" does not match a member of the enum; it was written as a string.`);
+                return `default: ${quote(defaultValue.value)}`;
+            }
+            return `default: ${reference}`;
+        }
+        case 'literal': {
+            if (typeof defaultValue.value === 'string') {
+                if (enumDefinition !== undefined) {
+                    const reference = enumReference(context, enumDefinition, defaultValue.value);
+                    if (reference !== undefined) {
+                        return `default: ${reference}`;
+                    }
+                }
+                if ((field.arrayDepth ?? 0) > 0) {
+                    if (defaultValue.value !== '[]') {
+                        return undefined;
+                    }
+                    return context.dialect === 'postgres'
+                        ? `default: () => ${quote(quote('{}'))}`
+                        : `default: () => ${quote(quote('[]'))}`;
+                }
+                if (field.type === 'hstore' && defaultValue.value === '{}') {
+                    return context.dialect === 'postgres'
+                        ? `default: () => ${quote(quote(''))}`
+                        : `default: () => ${quote(quote('{}'))}`;
+                }
+                if (field.type === 'json') {
+                    return `default: () => ${quote(quote(defaultValue.value))}`;
+                }
+                if (field.type === 'bytes') {
+                    context.warnings.push(`${label}: a literal default on a binary column cannot be represented; it was dropped.`);
+                    return undefined;
+                }
+                return `default: ${quote(defaultValue.value)}`;
+            }
+            return `default: ${String(defaultValue.value)}`;
+        }
+        default:
+            return undefined;
+    }
+}
+// ---------------------------------------------------------------------------
+// Members
+// ---------------------------------------------------------------------------
+function isCreatedTimestamp(field) {
+    return (field.type === 'dateTime' &&
+        !field.isNullable &&
+        !field.isAutoUpdated &&
+        field.default !== undefined &&
+        field.default.kind === 'now' &&
+        CREATED_FIELD_PATTERN.test(field.name));
+}
+function isUpdatedTimestamp(field) {
+    return field.isAutoUpdated && field.type === 'dateTime' && !field.isNullable;
+}
+function nameEntry(columnName, propName) {
+    return columnName === propName ? undefined : `name: ${quote(columnName)}`;
+}
+function compact(entries) {
+    return entries.filter((entry) => entry !== undefined);
+}
+function buildFieldMember(context, model, field, propName) {
+    const label = `${model.name}.${field.name}`;
+    const spec = columnSpecOf(context, label, field);
+    if (field.generated !== undefined) {
+        context.warnings.push(`${label}: the generated column expression ${field.generated.expression} is Python, not SQL, and has no TypeORM equivalent; ` +
+            `the property was written as a regular column.`);
+    }
+    const nameOption = nameEntry(field.columnName, propName);
+    const inCompositeKey = model.compositePrimaryKey?.includes(field.name) ?? false;
+    const nullableSuffix = field.isNullable ? ' | null' : '';
+    const property = `  ${propName}!: ${spec.tsType}${nullableSuffix};`;
+    if (field.isAutoUpdated && !isUpdatedTimestamp(field)) {
+        context.warnings.push(`${label}: an auto-updated timestamp must be a non-null date-time column to become @UpdateDateColumn; it was written as a plain column.`);
+    }
+    if (field.isPrimaryKey || inCompositeKey) {
+        const generated = field.default;
+        if (field.isPrimaryKey &&
+            !inCompositeKey &&
+            generated !== undefined &&
+            generated.kind === 'autoIncrement' &&
+            (field.type === 'int' || field.type === 'bigInt')) {
+            // SQLite only allows AUTOINCREMENT on an INTEGER PRIMARY KEY (which is already 64 bits
+            // wide and read as a number), so a bigint key there is written as a plain integer.
+            const sqliteInteger = context.dialect === 'sqlite' && field.type === 'bigInt';
+            const options = compact([
+                nameOption,
+                field.type === 'bigInt' && !sqliteInteger
+                    ? `type: 'bigint'`
+                    : undefined,
+            ]);
+            return {
+                lines: [
+                    ...decorator(use(context, 'PrimaryGeneratedColumn'), [`'increment'`], options),
+                    sqliteInteger ? `  ${propName}!: number;` : property,
+                ],
+            };
+        }
+        if (field.isPrimaryKey &&
+            !inCompositeKey &&
+            generated !== undefined &&
+            generated.kind === 'uuid' &&
+            field.type === 'uuid' &&
+            context.dialect !== 'sqlite') {
+            return {
+                lines: [
+                    ...decorator(use(context, 'PrimaryGeneratedColumn'), [`'uuid'`], compact([nameOption])),
+                    property,
+                ],
+            };
+        }
+        const entries = compact([
+            nameOption,
+            ...spec.typeEntries,
+            defaultEntryOf(context, label, field),
+        ]);
+        return {
+            lines: [
+                ...decorator(use(context, 'PrimaryColumn'), [], entries),
+                property,
+            ],
+        };
+    }
+    if (isUpdatedTimestamp(field)) {
+        return {
+            lines: [
+                ...decorator(use(context, 'UpdateDateColumn'), [], compact([nameOption, ...spec.typeEntries])),
+                property,
+            ],
+        };
+    }
+    if (isCreatedTimestamp(field)) {
+        return {
+            lines: [
+                ...decorator(use(context, 'CreateDateColumn'), [], compact([nameOption, ...spec.typeEntries])),
+                property,
+            ],
+        };
+    }
+    const entries = compact([
+        nameOption,
+        ...spec.typeEntries,
+        field.isNullable ? 'nullable: true' : undefined,
+        field.isUnique ? 'unique: true' : undefined,
+        defaultEntryOf(context, label, field),
+    ]);
+    return {
+        lines: [...decorator(use(context, 'Column'), [], entries), property],
+    };
+}
+/** Resolves the target column of a relation: an explicit to_field, otherwise the primary key. */
+function referencedKey(context, label, target, toField, depth = 0) {
+    if (depth > 5) {
+        return undefined;
+    }
+    const targetNames = namesOf(context, target);
+    const explicit = toField === undefined
+        ? undefined
+        : target.fields.find((field) => field.name === toField);
+    const column = explicit ?? target.fields.find((field) => field.isPrimaryKey);
+    if (column !== undefined) {
+        return {
+            property: targetNames.fields.get(column.name) ?? column.name,
+            spec: columnSpecOf(context, label, column),
+        };
+    }
+    const primaryRelation = target.relations.find((relation) => relation.isPrimaryKey === true);
+    if (primaryRelation !== undefined) {
+        const chained = findModel(context.schema, primaryRelation.targetModel);
+        const chainedKey = chained === undefined
+            ? undefined
+            : referencedKey(context, label, chained, primaryRelation.toField, depth + 1);
+        if (chainedKey !== undefined) {
+            return {
+                property: targetNames.scalars.get(primaryRelation.name) ?? chainedKey.property,
+                spec: chainedKey.spec,
+            };
+        }
+    }
+    return undefined;
+}
+/** Column name of the first primary key property of a model, for join tables. */
+function primaryKeyProperty(context, model) {
+    const primary = model.fields.find((field) => field.isPrimaryKey);
+    return primary === undefined
+        ? undefined
+        : namesOf(context, model).fields.get(primary.name);
+}
+function buildForwardMembers(context, model, inverseMembers) {
+    const members = [];
+    const names = namesOf(context, model);
+    for (const field of model.fields) {
+        members.push(buildFieldMember(context, model, field, names.fields.get(field.name) ?? field.name));
+    }
+    for (const relation of model.relations) {
+        const target = findModel(context.schema, relation.targetModel);
+        if (target === undefined) {
+            context.warnings.push(`${model.name}.${relation.name}: target model "${relation.targetModel}" does not exist in the schema; the relation was skipped.`);
+            continue;
+        }
+        if (relation.kind === 'manyToMany') {
+            addManyToMany(context, model, relation, target, members, inverseMembers);
+        }
+        else {
+            addSingleRelation(context, model, relation, target, members, inverseMembers);
+        }
+    }
+    return members;
+}
+function addInverse(inverseMembers, targetName, member) {
+    const existing = inverseMembers.get(targetName) ?? [];
+    existing.push(member);
+    inverseMembers.set(targetName, existing);
+}
+function addSingleRelation(context, model, relation, target, members, inverseMembers) {
+    const label = `${model.name}.${relation.name}`;
+    const names = namesOf(context, model);
+    const relationProp = names.relations.get(relation.name) ?? relation.name;
+    const inverseProp = context.inverseNames.get(label) ?? toSnakeCase(model.name);
+    const keyed = isKeyedRelation(model, relation);
+    const needsKey = keyed || relation.toField !== undefined;
+    const key = needsKey
+        ? referencedKey(context, label, target, relation.toField)
+        : undefined;
+    if (needsKey && key === undefined) {
+        context.warnings.push(`${label}: target model "${target.name}" has no single-column primary key to reference; the relation was skipped.`);
+        return;
+    }
+    if (relation.onDelete === 'setNull' && !relation.isNullable) {
+        context.warnings.push(`${label}: onDelete SET NULL on a required relation will fail at the database level; review the relation.`);
+    }
+    const scalarProp = names.scalars.get(relation.name);
+    if (keyed && key !== undefined && scalarProp !== undefined) {
+        members.push({
+            lines: [
+                ...decorator(use(context, 'PrimaryColumn'), [], compact([
+                    `name: ${quote(relation.columnName)}`,
+                    ...key.spec.typeEntries,
+                ])),
+                `  ${scalarProp}!: ${key.spec.tsType};`,
+            ],
+        });
+    }
+    const decoratorName = relation.kind === 'oneToOne' ? 'OneToOne' : 'ManyToOne';
+    const options = [
+        `onDelete: ${quote(ON_DELETE_NAMES[relation.onDelete])}`,
+        `nullable: ${relation.isNullable ? 'true' : 'false'}`,
+    ];
+    const joinEntries = compact([
+        `name: ${quote(relation.columnName)}`,
+        key !== undefined && relation.toField !== undefined
+            ? `referencedColumnName: ${quote(key.property)}`
+            : undefined,
+    ]);
+    const relationType = `${use(context, 'Relation')}<${target.name}>${relation.isNullable ? ' | null' : ''}`;
+    members.push({
+        lines: [
+            ...decorator(use(context, decoratorName), [`() => ${target.name}`, `(entity) => entity.${inverseProp}`], options),
+            ...decorator(use(context, 'JoinColumn'), [], joinEntries),
+            `  ${relationProp}!: ${relationType};`,
+        ],
+    });
+    if (relation.kind === 'oneToOne') {
+        addInverse(inverseMembers, target.name, {
+            lines: [
+                ...decorator(use(context, 'OneToOne'), [`() => ${model.name}`, `(entity) => entity.${relationProp}`], []),
+                `  ${inverseProp}!: ${use(context, 'Relation')}<${model.name}> | null;`,
+            ],
+        });
+    }
+    else {
+        addInverse(inverseMembers, target.name, {
+            lines: [
+                ...decorator(use(context, 'OneToMany'), [`() => ${model.name}`, `(entity) => entity.${relationProp}`], []),
+                `  ${inverseProp}!: ${model.name}[];`,
+            ],
+        });
+    }
+}
+function addManyToMany(context, model, relation, target, members, inverseMembers) {
+    const label = `${model.name}.${relation.name}`;
+    const names = namesOf(context, model);
+    const relationProp = names.relations.get(relation.name) ?? relation.name;
+    const inverseProp = context.inverseNames.get(label) ?? `${toSnakeCase(model.name)}_set`;
+    const ownerSnake = toSnakeCase(model.name);
+    const targetSnake = toSnakeCase(target.name);
+    const isSelfReference = model.name === target.name;
+    const ownerColumn = `${isSelfReference ? 'from_' : ''}${ownerSnake}_id`;
+    const targetColumn = `${isSelfReference ? 'to_' : ''}${targetSnake}_id`;
+    const ownerKey = primaryKeyProperty(context, model);
+    const targetKey = primaryKeyProperty(context, target);
+    const joinColumn = compact([
+        `name: ${quote(ownerColumn)}`,
+        ownerKey === undefined
+            ? undefined
+            : `referencedColumnName: ${quote(ownerKey)}`,
+    ]);
+    const inverseJoinColumn = compact([
+        `name: ${quote(targetColumn)}`,
+        targetKey === undefined
+            ? undefined
+            : `referencedColumnName: ${quote(targetKey)}`,
+    ]);
+    members.push({
+        lines: [
+            ...decorator(use(context, 'ManyToMany'), [`() => ${target.name}`, `(entity) => entity.${inverseProp}`], []),
+            ...decorator(use(context, 'JoinTable'), [], [
+                `name: ${quote(`${model.tableName}_${relation.name}`)}`,
+                `joinColumn: { ${joinColumn.join(', ')} }`,
+                `inverseJoinColumn: { ${inverseJoinColumn.join(', ')} }`,
+            ]),
+            `  ${relationProp}!: ${target.name}[];`,
+        ],
+    });
+    addInverse(inverseMembers, target.name, {
+        lines: [
+            ...decorator(use(context, 'ManyToMany'), [`() => ${model.name}`, `(entity) => entity.${relationProp}`], []),
+            `  ${inverseProp}!: ${model.name}[];`,
+        ],
+    });
+}
+// ---------------------------------------------------------------------------
+// Classes
+// ---------------------------------------------------------------------------
+function resolveIndexProperty(context, model, fieldName) {
+    const names = namesOf(context, model);
+    const relation = model.relations.find((candidate) => candidate.name === fieldName) ??
+        model.relations.find((candidate) => candidate.kind !== 'manyToMany' && candidate.columnName === fieldName);
+    if (relation !== undefined) {
+        return names.relations.get(relation.name) ?? fieldName;
+    }
+    const field = model.fields.find((candidate) => candidate.name === fieldName) ??
+        model.fields.find((candidate) => candidate.columnName === fieldName);
+    if (field !== undefined) {
+        return names.fields.get(field.name) ?? fieldName;
+    }
+    context.warnings.push(`${model.name}: an index references "${fieldName}", which is not a field of the model; it was written as-is.`);
+    return propertyName(context, fieldName);
+}
+function indexDecorator(context, model, index) {
+    const properties = `[${index.fields
+        .map((fieldName) => quote(resolveIndexProperty(context, model, fieldName)))
+        .join(', ')}]`;
+    const args = index.name === undefined ? [properties] : [quote(index.name), properties];
+    return decorator(use(context, index.isUnique ? 'Unique' : 'Index'), args, [], '');
+}
+function emitClass(context, model, members) {
+    const hasPrimaryKey = model.fields.some((field) => field.isPrimaryKey) ||
+        model.relations.some((relation) => relation.isPrimaryKey === true) ||
+        (model.compositePrimaryKey !== undefined &&
+            model.compositePrimaryKey.length > 0);
+    if (!hasPrimaryKey) {
+        context.warnings.push(`${model.name}: the model has no primary key; TypeORM requires at least one primary column.`);
+    }
+    const header = [
+        ...decorator(use(context, 'Entity'), [quote(model.tableName)], [], ''),
+    ];
+    for (const index of model.indexes) {
+        header.push(...indexDecorator(context, model, index));
+    }
+    const body = members.flatMap((member, position) => position === 0 ? member.lines : ['', ...member.lines]);
+    return [...header, `export class ${model.name} {`, ...body, '}'].join('\n');
+}
+//# sourceMappingURL=typeorm.js.map