ormbridge 0.3.0 → 0.5.0

package/dist/emitters/sqlalchemy.js

@@ -0,0 +1,1725 @@
+import { prismaOnlyWarnings } from '../prismaOnlyConstructs.js';
+import { limitIdentifier, toPascalCase, toSnakeCase } from '../naming.js';
+import { normalizeSchema } from '../transforms.js';
+export const SQLALCHEMY_STYLES = [
+    'sqlalchemy',
+    'sqlmodel',
+];
+/** True when a value is one of the supported `--style` values. */
+export function isSqlAlchemyStyle(value) {
+    return SQLALCHEMY_STYLES.includes(value);
+}
+// ---------------------------------------------------------------------------
+// Source text building: a tiny expression tree that wraps long calls like Black does
+// ---------------------------------------------------------------------------
+const MAX_LINE_WIDTH = 88;
+const INDENT = '    ';
+function group(open, items, close = ')') {
+    return { open, items, close };
+}
+function call(name, items) {
+    return group(`${name}(`, items);
+}
+function flat(node) {
+    if (typeof node === 'string') {
+        return node;
+    }
+    return `${node.open}${node.items.map(flat).join(', ')}${node.close}`;
+}
+function renderNode(node, column, indent) {
+    if (typeof node === 'string') {
+        return node;
+    }
+    const inline = flat(node);
+    if (node.items.length === 0 ||
+        (node.force !== true && column + inline.length < MAX_LINE_WIDTH)) {
+        return inline;
+    }
+    const pad = ' '.repeat(indent + INDENT.length);
+    const lines = node.items.map((item) => `${pad}${renderNode(item, pad.length, pad.length)},`);
+    return `${node.open}\n${lines.join('\n')}\n${' '.repeat(indent)}${node.close}`;
+}
+/** Renders a statement at an indentation level. */
+function statement(node, level) {
+    const indent = level * INDENT.length;
+    return `${' '.repeat(indent)}${renderNode(node, indent, indent)}`;
+}
+function pyString(value) {
+    return JSON.stringify(value);
+}
+// ---------------------------------------------------------------------------
+// Names
+// ---------------------------------------------------------------------------
+const PYTHON_KEYWORDS = [
+    'False',
+    'None',
+    'True',
+    'and',
+    'as',
+    'assert',
+    'async',
+    'await',
+    'break',
+    'class',
+    'continue',
+    'def',
+    'del',
+    'elif',
+    'else',
+    'except',
+    'finally',
+    'for',
+    'from',
+    'global',
+    'if',
+    'import',
+    'in',
+    'is',
+    'lambda',
+    'nonlocal',
+    'not',
+    'or',
+    'pass',
+    'raise',
+    'return',
+    'try',
+    'while',
+    'with',
+    'yield',
+];
+/** Names the generated module imports or relies on; no class, enum or table variable may take them. */
+const MODULE_RESERVED = [
+    ...PYTHON_KEYWORDS,
+    'ARRAY',
+    'Any',
+    'BigInteger',
+    'Base',
+    'Boolean',
+    'Column',
+    'Date',
+    'DateTime',
+    'DeclarativeBase',
+    'Enum',
+    'Field',
+    'Float',
+    'ForeignKey',
+    'ForeignKeyConstraint',
+    'HSTORE',
+    'INET',
+    'INT4RANGE',
+    'INT8RANGE',
+    'DATERANGE',
+    'NUMRANGE',
+    'TSTZRANGE',
+    'Index',
+    'Integer',
+    'Interval',
+    'JSON',
+    'LargeBinary',
+    'Mapped',
+    'Numeric',
+    'Optional',
+    'PrimaryKeyConstraint',
+    'Range',
+    'Relationship',
+    'SQLModel',
+    'String',
+    'Table',
+    'Text',
+    'Time',
+    'UniqueConstraint',
+    'Uuid',
+    'bool',
+    'bytes',
+    'datetime',
+    'decimal',
+    'dict',
+    'enum',
+    'false',
+    'float',
+    'func',
+    'int',
+    'list',
+    'mapped_column',
+    'object',
+    'relationship',
+    'str',
+    'text',
+    'true',
+    'uuid',
+];
+/** Names that, as an attribute of a class, would shadow something the class body still needs. */
+const CLASS_RESERVED = [
+    ...MODULE_RESERVED,
+    'metadata',
+    'registry',
+    'self',
+    'cls',
+];
+/** Attribute names of `SQLModel` (pydantic's `BaseModel` and SQLModel itself) a field must not shadow. */
+const SQLMODEL_RESERVED = [
+    'construct',
+    'copy',
+    'dict',
+    'fields',
+    'from_orm',
+    'json',
+    'parse_file',
+    'parse_obj',
+    'parse_raw',
+    'schema',
+    'schema_json',
+    'update_forward_refs',
+    'validate',
+];
+const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** The first free name: `base`, then `base2`, `base3`, ... A name also counts as taken when `others` holds it. */
+function uniqueName(base, used, others = new Set()) {
+    let candidate = base;
+    let suffix = 2;
+    while (used.has(candidate) || others.has(candidate)) {
+        candidate = `${base}${suffix}`;
+        suffix += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function pluralize(word) {
+    if (/(s|x|z|ch|sh)$/i.test(word)) {
+        return `${word}es`;
+    }
+    if (/[^aeiou]y$/i.test(word)) {
+        return `${word.slice(0, -1)}ies`;
+    }
+    return `${word}s`;
+}
+/** A snake_case Python identifier built from any text. */
+function snakeIdentifier(raw, fallback) {
+    const snake = toSnakeCase(raw);
+    const safe = snake.replace(/[^A-Za-z0-9_]/g, '_');
+    if (safe === '') {
+        return fallback;
+    }
+    return /^[0-9]/.test(safe) ? `${fallback}_${safe}` : safe;
+}
+function sa(context, name) {
+    (context.collector?.sa ?? context.saImports).add(name);
+    return name;
+}
+function pg(context, name) {
+    (context.collector?.pg ?? context.pgImports).add(name);
+    return name;
+}
+/** Builds a column type, collecting the imports it needs instead of registering them. */
+function collectTypes(context, build) {
+    const uses = { sa: new Set(), pg: new Set() };
+    const previous = context.collector;
+    context.collector = uses;
+    try {
+        return { ...build(), uses };
+    }
+    finally {
+        context.collector = previous;
+    }
+}
+/** Registers the imports of a column type that is written to the output. */
+function commitTypes(context, type) {
+    for (const name of type.uses.sa) {
+        context.saImports.add(name);
+    }
+    for (const name of type.uses.pg) {
+        context.pgImports.add(name);
+    }
+}
+function framework(context, name) {
+    context.frameworkImports.add(name);
+    return name;
+}
+function mod(context, name) {
+    context.modules.add(name);
+    return name;
+}
+function optional(context, annotation) {
+    context.typingImports.add('Optional');
+    return `Optional[${annotation}]`;
+}
+function metadataExpression(context) {
+    return context.style === 'sqlmodel' ? 'SQLModel.metadata' : 'Base.metadata';
+}
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+/** Writes the IR as a SQLAlchemy 2.0 (or SQLModel) models.py. */
+export function emitSqlAlchemy(schema, options) {
+    const style = options.style ?? 'sqlalchemy';
+    const prepared = options.naming === 'normalize' ? normalizeSchema(schema) : schema;
+    const context = {
+        schema: prepared,
+        style,
+        naming: options.naming,
+        // Views, composite foreign keys, onUpdate actions and database default expressions are written here.
+        warnings: prismaOnlyWarnings(prepared, true).filter((warning) => !warning.includes('the onUpdate action') &&
+            !warning.includes('has no equivalent here; the relation was dropped') &&
+            !warning.includes('the database default expression')),
+        moduleNames: new Set(MODULE_RESERVED),
+        classes: new Map(),
+        enums: new Map(),
+        links: [],
+        constraintNames: new Set(),
+        attributes: new Set(),
+        saImports: new Set(),
+        pgImports: new Set(),
+        collector: undefined,
+        frameworkImports: new Set(),
+        modules: new Set(),
+        typingImports: new Set(),
+        associations: [],
+    };
+    const mapped = prepared.models.filter((model) => model.isView !== true);
+    allocateClasses(context, mapped);
+    allocateEnums(context);
+    allocateAttributes(context, mirroredManyToMany(mapped));
+    buildLinks(context, mapped);
+    const ordered = orderClasses(context, mapped);
+    const blocks = [];
+    if (style === 'sqlalchemy') {
+        framework(context, 'DeclarativeBase');
+        blocks.push('class Base(DeclarativeBase):\n    pass');
+    }
+    for (const info of context.enums.values()) {
+        blocks.push(renderEnum(context, info));
+    }
+    for (const association of context.associations) {
+        blocks.push(renderAssociation(context, association));
+    }
+    for (const info of ordered) {
+        blocks.push(renderClass(context, info));
+    }
+    for (const model of prepared.models) {
+        if (model.isView === true) {
+            blocks.push(renderView(context, model));
+        }
+    }
+    const header = '# Generated by ormbridge. Review the output before creating tables or migrations.';
+    const importBlock = buildImports(context);
+    const text = `${header}\n\n${importBlock}\n\n\n${blocks.join('\n\n\n')}\n`;
+    return { text, warnings: context.warnings };
+}
+// ---------------------------------------------------------------------------
+// Allocation of names
+// ---------------------------------------------------------------------------
+function classNameOf(context, model) {
+    let name = model.name;
+    if (!IDENTIFIER_PATTERN.test(name)) {
+        name = toPascalCase(model.name).replace(/[^A-Za-z0-9_]/g, '_');
+        if (name === '' || /^[0-9]/.test(name)) {
+            name = `Model${name}`;
+        }
+    }
+    if (context.moduleNames.has(name)) {
+        const renamed = uniqueName(`${name}Model`, context.moduleNames);
+        context.warnings.push(`${model.name}: the name collides with a Python or SQLAlchemy name used by the module; the class was written as ${renamed}.`);
+        return renamed;
+    }
+    context.moduleNames.add(name);
+    if (name !== model.name) {
+        context.warnings.push(`${model.name}: not a valid Python class name; the class was written as ${name}.`);
+    }
+    return name;
+}
+function allocateClasses(context, models) {
+    for (const model of models) {
+        context.classes.set(model.name, {
+            model,
+            className: classNameOf(context, model),
+            used: new Set(context.style === 'sqlmodel'
+                ? [...CLASS_RESERVED, ...SQLMODEL_RESERVED]
+                : CLASS_RESERVED),
+            fieldAttrs: new Map(),
+            columnAttrs: new Map(),
+            relationAttrs: new Map(),
+            incoming: [],
+            position: 0,
+        });
+    }
+}
+function allocateEnums(context) {
+    for (const definition of context.schema.enums) {
+        if (definition.values.length === 0) {
+            context.warnings.push(`enum ${definition.name}: an enum without values cannot be written; fields that use it became plain strings.`);
+            continue;
+        }
+        let className = IDENTIFIER_PATTERN.test(definition.name)
+            ? definition.name
+            : toPascalCase(definition.name).replace(/[^A-Za-z0-9_]/g, '_') || 'Enum_';
+        if (/^[0-9]/.test(className)) {
+            className = `Enum${className}`;
+        }
+        if (context.moduleNames.has(className)) {
+            className = `${className}Enum`;
+        }
+        className = uniqueName(className, context.moduleNames);
+        if (className !== definition.name) {
+            context.warnings.push(`enum ${definition.name}: the Python class was named ${className}.`);
+        }
+        const dbName = definition.dbName ?? definition.name;
+        const used = new Set();
+        const memberNames = [];
+        for (const value of definition.values) {
+            let member = value.name.replace(/[^A-Za-z0-9_]/g, '_');
+            if (member === '' || /^[0-9]/.test(member) || member.startsWith('_')) {
+                member = `v_${member.replace(/^_+/, '')}`;
+            }
+            if (PYTHON_KEYWORDS.includes(member) ||
+                member === 'name' ||
+                member === 'value' ||
+                member === 'mro') {
+                member = `${member}_`;
+            }
+            const allocated = uniqueName(member, used);
+            if (allocated !== value.name) {
+                context.warnings.push(`enum ${definition.name}: the member "${value.name}" was written as ${allocated}.`);
+            }
+            memberNames.push(allocated);
+        }
+        context.enums.set(definition.name, {
+            definition,
+            className,
+            dbName: context.naming === 'normalize' ? toSnakeCase(dbName) || dbName : dbName,
+            memberNames,
+        });
+    }
+}
+/** A snake_case attribute for a name of the source, repaired when it would shadow or collide. */
+function attributeName(context, info, raw, owner) {
+    const base = snakeIdentifier(raw, 'field');
+    let candidate = base;
+    if (info.used.has(candidate) || context.moduleNames.has(candidate)) {
+        candidate = `${base}_`;
+    }
+    const allocated = uniqueName(candidate, info.used, context.moduleNames);
+    context.attributes.add(allocated);
+    if (allocated !== base && !CLASS_RESERVED.includes(base)) {
+        context.warnings.push(`${owner}: the name "${raw}" collides with another attribute of the class or a name used by the module; it was written as ${allocated}.`);
+    }
+    else if (allocated !== base) {
+        context.warnings.push(`${owner}: "${raw}" would shadow a name the class needs; the attribute was written as ${allocated}.`);
+    }
+    return allocated;
+}
+function allocateAttributes(context, mirrored) {
+    for (const info of context.classes.values()) {
+        const model = info.model;
+        for (const field of model.fields) {
+            info.fieldAttrs.set(field.name, attributeName(context, info, field.name, `${model.name}.${field.name}`));
+        }
+        for (const key of model.compositeForeignKeys ?? []) {
+            info.relationAttrs.set(key.name, attributeName(context, info, key.name, `${model.name}.${key.name}`));
+        }
+        for (const relation of model.relations) {
+            if (mirrored.has(`${model.name}.${relation.name}`)) {
+                continue;
+            }
+            info.relationAttrs.set(relation.name, attributeName(context, info, relation.name, `${model.name}.${relation.name}`));
+        }
+        for (const relation of model.relations) {
+            if (relation.kind === 'manyToMany') {
+                continue;
+            }
+            // The foreign-key column keeps its own name unless the relationship already took it.
+            const wanted = snakeIdentifier(relation.columnName, 'column');
+            const column = info.used.has(wanted) ? `${wanted}_id` : wanted;
+            info.columnAttrs.set(relation.name, attributeName(context, info, column, `${model.name}.${relation.name}`));
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Keys and links
+// ---------------------------------------------------------------------------
+function isKeyRelation(model, relation) {
+    return (relation.isPrimaryKey === true ||
+        (model.compositePrimaryKey?.includes(relation.name) ?? false));
+}
+/**
+ * Finds the column a foreign key points at: the named column of the target, otherwise its primary key.
+ * A key that is itself a relation (multi-table inheritance) is followed to the scalar underneath.
+ */
+function resolveKey(context, modelName, name, depth = 0) {
+    const info = context.classes.get(modelName);
+    if (info === undefined || depth > 8) {
+        return undefined;
+    }
+    const model = info.model;
+    let wanted = name;
+    if (wanted === undefined) {
+        const primary = model.fields.find((field) => field.isPrimaryKey);
+        if (primary !== undefined) {
+            wanted = primary.name;
+        }
+        else {
+            const keyRelation = model.relations.find((relation) => relation.isPrimaryKey === true);
+            wanted =
+                keyRelation?.name ??
+                    (model.compositePrimaryKey?.length === 1
+                        ? model.compositePrimaryKey[0]
+                        : undefined);
+        }
+    }
+    if (wanted === undefined) {
+        return undefined;
+    }
+    const field = model.fields.find((candidate) => candidate.name === wanted) ??
+        model.fields.find((candidate) => candidate.columnName === wanted);
+    if (field !== undefined) {
+        return {
+            field,
+            columnName: field.columnName,
+            attr: info.fieldAttrs.get(field.name) ?? field.name,
+        };
+    }
+    const relation = model.relations.find((candidate) => candidate.kind !== 'manyToMany' && candidate.name === wanted);
+    if (relation === undefined) {
+        return undefined;
+    }
+    const inner = resolveKey(context, relation.targetModel, relation.toField, depth + 1);
+    if (inner === undefined) {
+        return undefined;
+    }
+    return {
+        field: inner.field,
+        columnName: relation.columnName,
+        attr: info.columnAttrs.get(relation.name) ?? relation.columnName,
+    };
+}
+function pairKey(first, second) {
+    return first <= second
+        ? `${first}\u0000${second}`
+        : `${second}\u0000${first}`;
+}
+function defaultReverseName(owner, kind, sharedTarget, relationName) {
+    const base = snakeIdentifier(owner.model.name, 'model');
+    const name = kind === 'oneToOne' ? base : pluralize(base);
+    return sharedTarget
+        ? `${name}_${snakeIdentifier(relationName, 'rel')}`
+        : name;
+}
+/**
+ * A schema may list both sides of one many-to-many relation (each names the other as its related
+ * name). The first side is the owner; the other is the reverse side and gets no relation of its own.
+ */
+function mirroredManyToMany(models) {
+    const mirrored = new Set();
+    for (const model of models) {
+        for (const relation of model.relations) {
+            if (relation.kind !== 'manyToMany' ||
+                relation.relatedName === undefined ||
+                mirrored.has(`${model.name}.${relation.name}`)) {
+                continue;
+            }
+            const other = models.find((candidate) => candidate.name === relation.targetModel);
+            const counterpart = other?.relations.find((candidate) => candidate.kind === 'manyToMany' &&
+                candidate.name === relation.relatedName &&
+                candidate.targetModel === model.name);
+            if (other !== undefined && counterpart !== undefined && other !== model) {
+                mirrored.add(`${other.name}.${counterpart.name}`);
+            }
+        }
+    }
+    return mirrored;
+}
+function buildLinks(context, models) {
+    const raw = [];
+    const mirrored = mirroredManyToMany(models);
+    for (const model of models) {
+        const owner = context.classes.get(model.name);
+        if (owner === undefined) {
+            continue;
+        }
+        for (const relation of model.relations) {
+            const target = context.classes.get(relation.targetModel);
+            if (target === undefined) {
+                context.warnings.push(`${model.name}.${relation.name}: the target model ${relation.targetModel} is not a mapped table (it is missing or a view); ${relation.kind === 'manyToMany' ? 'the relation was dropped' : 'the foreign key column was written without a ForeignKey or a relationship'}.`);
+                continue;
+            }
+            if (relation.kind === 'manyToMany') {
+                if (mirrored.has(`${model.name}.${relation.name}`)) {
+                    continue;
+                }
+                raw.push(manyToManyLink(context, owner, target, relation));
+            }
+            else {
+                raw.push(foreignKeyLink(context, owner, target, relation));
+            }
+        }
+        for (const key of model.compositeForeignKeys ?? []) {
+            const target = context.classes.get(key.targetModel);
+            if (target === undefined) {
+                context.warnings.push(`${model.name}.${key.name}: the target model ${key.targetModel} is not a mapped table; the composite foreign key was dropped and its columns kept as plain columns.`);
+                continue;
+            }
+            raw.push(compositeLink(context, owner, target, key));
+        }
+    }
+    const links = raw.filter((link) => link.localAttrs.length > 0 || link.association !== undefined);
+    // More than one foreign key between a pair of classes needs `foreign_keys` on every side.
+    const counts = new Map();
+    for (const link of links) {
+        if (link.kind === 'manyToMany') {
+            continue;
+        }
+        const key = pairKey(link.owner.model.name, link.target.model.name);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    // Reverse names: a model that points twice at the same target needs distinct reverse names.
+    const sharedTargets = new Map();
+    for (const link of links) {
+        const key = `${link.owner.model.name}\u0000${link.target.model.name}\u0000${link.kind}`;
+        sharedTargets.set(key, (sharedTargets.get(key) ?? 0) + 1);
+    }
+    for (const link of links) {
+        if (link.kind !== 'manyToMany') {
+            link.ambiguous =
+                (counts.get(pairKey(link.owner.model.name, link.target.model.name)) ??
+                    0) > 1;
+        }
+        const sharedKey = `${link.owner.model.name}\u0000${link.target.model.name}\u0000${link.kind}`;
+        const shared = (sharedTargets.get(sharedKey) ?? 0) > 1;
+        const wanted = link.relatedName === undefined
+            ? defaultReverseName(link.owner, link.kind, shared, link.name)
+            : snakeIdentifier(link.relatedName, 'related');
+        const base = link.target.used.has(wanted) || context.moduleNames.has(wanted)
+            ? `${wanted}_`
+            : wanted;
+        link.reverseAttr = uniqueName(base, link.target.used, context.moduleNames);
+        context.attributes.add(link.reverseAttr);
+        link.target.incoming.push(link);
+    }
+    context.links = links;
+    for (const association of context.associations) {
+        association.variable = uniqueName(snakeIdentifier(association.tableName, 'association'), context.moduleNames, context.attributes);
+    }
+}
+function foreignKeyLink(context, owner, target, relation) {
+    const key = resolveKey(context, target.model.name, relation.toField);
+    if (key === undefined) {
+        context.warnings.push(`${owner.model.name}.${relation.name}: ${target.model.name} has no ${relation.toField === undefined ? 'primary key' : `column ${relation.toField}`} to reference; the foreign key points at ${target.model.tableName}.id.`);
+    }
+    return {
+        owner,
+        target,
+        kind: relation.kind === 'oneToOne' ? 'oneToOne' : 'foreignKey',
+        name: relation.name,
+        isNullable: relation.isNullable,
+        onDelete: relation.onDelete,
+        onUpdate: relation.onUpdate,
+        constraintName: relation.constraintName,
+        relatedName: relation.relatedName,
+        forwardAttr: owner.relationAttrs.get(relation.name) ?? relation.name,
+        reverseAttr: '',
+        localColumns: [relation.columnName],
+        localAttrs: [owner.columnAttrs.get(relation.name) ?? relation.columnName],
+        remoteColumns: [key?.columnName ?? 'id'],
+        remoteAttrs: [key?.attr ?? 'id'],
+        composite: false,
+        ambiguous: false,
+        selfReference: owner === target,
+        association: undefined,
+    };
+}
+function compositeLink(context, owner, target, key) {
+    const localColumns = [];
+    const localAttrs = [];
+    for (const name of key.fields) {
+        const field = owner.model.fields.find((candidate) => candidate.name === name);
+        localColumns.push(field?.columnName ?? name);
+        localAttrs.push(owner.fieldAttrs.get(name) ?? name);
+    }
+    const remoteColumns = [];
+    const remoteAttrs = [];
+    for (const name of key.references) {
+        const resolved = resolveKey(context, target.model.name, name);
+        remoteColumns.push(resolved?.columnName ?? name);
+        remoteAttrs.push(resolved?.attr ?? name);
+    }
+    return {
+        owner,
+        target,
+        kind: key.kind,
+        name: key.name,
+        isNullable: key.isNullable,
+        onDelete: key.onDelete,
+        onUpdate: key.onUpdate,
+        constraintName: key.constraintName,
+        relatedName: key.relatedName,
+        forwardAttr: owner.relationAttrs.get(key.name) ?? key.name,
+        reverseAttr: '',
+        localColumns,
+        localAttrs,
+        remoteColumns,
+        remoteAttrs,
+        composite: true,
+        ambiguous: false,
+        selfReference: owner === target,
+        association: undefined,
+    };
+}
+function manyToManyLink(context, owner, target, relation) {
+    const selfReference = owner === target;
+    const ownerSnake = snakeIdentifier(owner.model.name, 'model');
+    const targetSnake = snakeIdentifier(target.model.name, 'model');
+    const ownerColumn = selfReference
+        ? `from_${ownerSnake}_id`
+        : `${ownerSnake}_id`;
+    const targetColumn = selfReference
+        ? `to_${targetSnake}_id`
+        : `${targetSnake}_id`;
+    const tableName = `${owner.model.tableName}_${relation.name}`;
+    const ownerKey = resolveKey(context, owner.model.name, undefined);
+    const targetKey = resolveKey(context, target.model.name, undefined);
+    for (const [info, key] of [
+        [owner, ownerKey],
+        [target, targetKey],
+    ]) {
+        if (key === undefined) {
+            context.warnings.push(`${owner.model.name}.${relation.name}: ${info.model.name} has no single-column primary key; the association table column references ${info.model.tableName}.id.`);
+        }
+    }
+    const association = {
+        variable: '',
+        tableName,
+        ownerColumn,
+        targetColumn,
+        ownerKey,
+        targetKey,
+        selfReference,
+    };
+    context.associations.push(association);
+    return {
+        owner,
+        target,
+        kind: 'manyToMany',
+        name: relation.name,
+        isNullable: false,
+        onDelete: 'cascade',
+        onUpdate: undefined,
+        constraintName: undefined,
+        relatedName: relation.relatedName,
+        forwardAttr: owner.relationAttrs.get(relation.name) ?? relation.name,
+        reverseAttr: '',
+        localColumns: [],
+        localAttrs: [],
+        remoteColumns: [],
+        remoteAttrs: [],
+        composite: false,
+        ambiguous: false,
+        selfReference,
+        association,
+    };
+}
+/** Orders the classes so that a class follows the classes its foreign keys point at where it can. */
+function orderClasses(context, models) {
+    const ordered = [];
+    const done = new Set();
+    const visiting = new Set();
+    const visit = (model) => {
+        if (done.has(model.name) || visiting.has(model.name)) {
+            return;
+        }
+        visiting.add(model.name);
+        for (const link of context.links) {
+            if (link.owner.model === model &&
+                link.kind !== 'manyToMany' &&
+                link.target.model !== model) {
+                visit(link.target.model);
+            }
+        }
+        visiting.delete(model.name);
+        done.add(model.name);
+        const info = context.classes.get(model.name);
+        if (info !== undefined) {
+            info.position = ordered.length;
+            ordered.push(info);
+        }
+    };
+    for (const model of models) {
+        visit(model);
+    }
+    return ordered;
+}
+// ---------------------------------------------------------------------------
+// Enums
+// ---------------------------------------------------------------------------
+function renderEnum(context, info) {
+    mod(context, 'enum');
+    const lines = [`class ${info.className}(enum.Enum):`];
+    info.definition.values.forEach((value, position) => {
+        lines.push(`${INDENT}${info.memberNames[position] ?? value.name} = ${pyString(value.dbValue)}`);
+    });
+    return lines.join('\n');
+}
+function enumOf(context, field) {
+    return field.enumName === undefined
+        ? undefined
+        : context.enums.get(field.enumName);
+}
+function enumType(context, info) {
+    mod(context, 'enum');
+    return call(sa(context, 'Enum'), [
+        info.className,
+        `name=${pyString(info.dbName)}`,
+        'values_callable=lambda members: [member.value for member in members]',
+    ]);
+}
+const RANGE_TYPES = {
+    int: ['INT4RANGE', 'int'],
+    bigInt: ['INT8RANGE', 'int'],
+    decimal: ['NUMRANGE', 'decimal.Decimal'],
+    date: ['DATERANGE', 'datetime.date'],
+    dateTime: ['TSTZRANGE', 'datetime.datetime'],
+};
+function withSqliteFallback(context, type, fallback) {
+    return call(`${flat(type)}.with_variant`, [fallback, '"sqlite"']);
+}
+function scalarType(context, model, field) {
+    const label = `${model.name}.${field.name}`;
+    const enumInfo = enumOf(context, field);
+    if (enumInfo !== undefined) {
+        return {
+            sa: enumType(context, enumInfo),
+            py: enumInfo.className,
+            needsSaType: true,
+            fieldArgs: [],
+        };
+    }
+    switch (field.type) {
+        case 'string':
+            return {
+                sa: field.maxLength === undefined
+                    ? sa(context, 'String')
+                    : call(sa(context, 'String'), [String(field.maxLength)]),
+                py: 'str',
+                needsSaType: false,
+                fieldArgs: field.maxLength === undefined
+                    ? []
+                    : [`max_length=${String(field.maxLength)}`],
+            };
+        case 'text':
+            return {
+                sa: sa(context, 'Text'),
+                py: 'str',
+                needsSaType: true,
+                fieldArgs: [],
+            };
+        case 'int':
+            return {
+                sa: sa(context, 'Integer'),
+                py: 'int',
+                needsSaType: false,
+                fieldArgs: [],
+            };
+        case 'bigInt':
+            return {
+                sa: sa(context, 'BigInteger'),
+                py: 'int',
+                needsSaType: true,
+                fieldArgs: [],
+            };
+        case 'float':
+            return {
+                sa: sa(context, 'Float'),
+                py: 'float',
+                needsSaType: false,
+                fieldArgs: [],
+            };
+        case 'decimal': {
+            const hasPrecision = field.maxDigits !== undefined;
+            return {
+                sa: hasPrecision
+                    ? call(sa(context, 'Numeric'), [
+                        String(field.maxDigits),
+                        String(field.decimalPlaces ?? 0),
+                    ])
+                    : sa(context, 'Numeric'),
+                py: `${mod(context, 'decimal')}.Decimal`,
+                needsSaType: false,
+                fieldArgs: hasPrecision
+                    ? [
+                        `max_digits=${String(field.maxDigits)}`,
+                        `decimal_places=${String(field.decimalPlaces ?? 0)}`,
+                    ]
+                    : [],
+            };
+        }
+        case 'boolean':
+            return {
+                sa: sa(context, 'Boolean'),
+                py: 'bool',
+                needsSaType: false,
+                fieldArgs: [],
+            };
+        case 'dateTime':
+            return {
+                sa: call(sa(context, 'DateTime'), ['timezone=True']),
+                py: `${mod(context, 'datetime')}.datetime`,
+                needsSaType: true,
+                fieldArgs: [],
+            };
+        case 'date':
+            return {
+                sa: sa(context, 'Date'),
+                py: `${mod(context, 'datetime')}.date`,
+                needsSaType: false,
+                fieldArgs: [],
+            };
+        case 'time':
+            return {
+                sa: sa(context, 'Time'),
+                py: `${mod(context, 'datetime')}.time`,
+                needsSaType: false,
+                fieldArgs: [],
+            };
+        case 'duration':
+            return {
+                sa: sa(context, 'Interval'),
+                py: `${mod(context, 'datetime')}.timedelta`,
+                needsSaType: false,
+                fieldArgs: [],
+            };
+        case 'uuid':
+            return {
+                sa: sa(context, 'Uuid'),
+                py: `${mod(context, 'uuid')}.UUID`,
+                needsSaType: false,
+                fieldArgs: [],
+            };
+        case 'json':
+            context.typingImports.add('Any');
+            return {
+                // None means SQL NULL for a nullable column, not the JSON value null.
+                sa: field.isNullable
+                    ? call(sa(context, 'JSON'), ['none_as_null=True'])
+                    : sa(context, 'JSON'),
+                py: 'Any',
+                needsSaType: true,
+                fieldArgs: [],
+            };
+        case 'bytes':
+            return {
+                sa: sa(context, 'LargeBinary'),
+                py: 'bytes',
+                needsSaType: false,
+                fieldArgs: [],
+            };
+        case 'ipAddress':
+            return {
+                sa: withSqliteFallback(context, call(`${pg(context, 'INET')}`, []), call(sa(context, 'String'), ['45'])),
+                py: 'str',
+                needsSaType: true,
+                fieldArgs: [],
+            };
+        case 'hstore':
+            return {
+                sa: withSqliteFallback(context, call(pg(context, 'HSTORE'), []), call(sa(context, 'JSON'), [])),
+                py: 'dict[str, str]',
+                needsSaType: true,
+                fieldArgs: [],
+            };
+        case 'range': {
+            const entry = RANGE_TYPES[field.rangeOf ?? 'int'];
+            if (field.rangeOf === undefined) {
+                context.warnings.push(`${label}: the range field has no element type; it was written as INT4RANGE.`);
+            }
+            const [rangeName, element] = entry ?? ['INT4RANGE', 'int'];
+            const elementModule = element.split('.')[0] ?? '';
+            if (elementModule === 'decimal' || elementModule === 'datetime') {
+                mod(context, elementModule);
+            }
+            return {
+                sa: withSqliteFallback(context, call(pg(context, rangeName), []), call(sa(context, 'JSON'), [])),
+                py: `${pg(context, 'Range')}[${element}]`,
+                needsSaType: true,
+                fieldArgs: [],
+            };
+        }
+        default:
+            return {
+                sa: sa(context, 'String'),
+                py: 'str',
+                needsSaType: false,
+                fieldArgs: [],
+            };
+    }
+}
+/** Wraps the element type of an array column, one level per dimension. */
+function columnType(context, model, field) {
+    return collectTypes(context, () => arrayOrScalarType(context, model, field));
+}
+function arrayOrScalarType(context, model, field) {
+    const element = scalarType(context, model, field);
+    const depth = field.arrayDepth ?? 0;
+    if (depth === 0) {
+        return element;
+    }
+    let py = element.py;
+    for (let level = 0; level < depth; level += 1) {
+        py = `list[${py}]`;
+    }
+    const arguments_ = [element.sa];
+    if (depth > 1) {
+        arguments_.push(`dimensions=${String(depth)}`);
+    }
+    return {
+        sa: withSqliteFallback(context, call(sa(context, 'ARRAY'), arguments_), call(sa(context, 'JSON'), [])),
+        py,
+        needsSaType: true,
+        fieldArgs: [],
+    };
+}
+/** The type of a foreign-key column: the type of the key it references. */
+function keyColumnType(context, model, key) {
+    if (key === undefined) {
+        return collectTypes(context, () => ({
+            sa: sa(context, 'Integer'),
+            py: 'int',
+            needsSaType: false,
+            fieldArgs: [],
+        }));
+    }
+    // A key never needs the autoincrement-friendly variant, and an enum or array key is rare enough to share the path.
+    return columnType(context, model, { ...key.field });
+}
+/** A Python expression for a JSON text, as a factory that returns a fresh value; undefined when it is not JSON. */
+function jsonFactory(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (Array.isArray(parsed) && parsed.length === 0) {
+        return 'list';
+    }
+    if (typeof parsed === 'object' &&
+        parsed !== null &&
+        !Array.isArray(parsed) &&
+        Object.keys(parsed).length === 0) {
+        return 'dict';
+    }
+    return `lambda: ${pythonLiteral(parsed)}`;
+}
+function pythonLiteral(value) {
+    if (value === null) {
+        return 'None';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'True' : 'False';
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return pyString(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(pythonLiteral).join(', ')}]`;
+    }
+    const entries = Object.entries(value).map(([key, entry]) => `${pyString(key)}: ${pythonLiteral(entry)}`);
+    return `{${entries.join(', ')}}`;
+}
+function literalDefault(context, model, field, value) {
+    const label = `${model.name}.${field.name}`;
+    const isArray = (field.arrayDepth ?? 0) > 0;
+    if (typeof value === 'boolean' || field.type === 'boolean') {
+        const truth = typeof value === 'boolean'
+            ? value
+            : String(value).toLowerCase() === 'true';
+        return {
+            server: call(sa(context, truth ? 'true' : 'false'), []),
+            literal: truth ? 'True' : 'False',
+        };
+    }
+    if (isArray) {
+        if (value === '[]' || value === '{}') {
+            return { client: 'list', factory: 'list' };
+        }
+        context.warnings.push(`${label}: the array default ${pyString(String(value))} has no portable form and was dropped.`);
+        return {};
+    }
+    if (field.type === 'json') {
+        const text = String(value);
+        const result = {
+            server: call(sa(context, 'text'), [
+                pyString(`'${text.replace(/'/g, "''")}'`),
+            ]),
+        };
+        // SQLModel passes the Python default of every field to the INSERT, and a JSON column would
+        // store its None as the JSON value null, so the same value is also given as a factory.
+        const factory = jsonFactory(text);
+        if (factory !== undefined) {
+            result.factory = factory;
+        }
+        return result;
+    }
+    if (field.type === 'hstore') {
+        return value === '{}' ? { client: 'dict', factory: 'dict' } : {};
+    }
+    const numeric = field.type === 'int' ||
+        field.type === 'bigInt' ||
+        field.type === 'float' ||
+        field.type === 'decimal';
+    if (numeric && /^-?\d+(\.\d+)?$/.test(String(value))) {
+        return {
+            server: call(sa(context, 'text'), [pyString(String(value))]),
+            literal: field.type === 'decimal' ? undefined : String(value),
+        };
+    }
+    const text = String(value);
+    return {
+        server: pyString(text),
+        literal: field.type === 'string' || field.type === 'text'
+            ? pyString(text)
+            : undefined,
+    };
+}
+function nowExpression(context, field) {
+    const funcName = sa(context, 'func');
+    if (field.type === 'date') {
+        return `${funcName}.current_date()`;
+    }
+    if (field.type === 'time') {
+        return `${funcName}.current_time()`;
+    }
+    return `${funcName}.now()`;
+}
+function defaultOf(context, model, field) {
+    const label = `${model.name}.${field.name}`;
+    const result = {};
+    const value = field.default;
+    if (value !== undefined) {
+        switch (value.kind) {
+            case 'autoIncrement':
+                break;
+            case 'now':
+                result.server = nowExpression(context, field);
+                break;
+            case 'uuid':
+                result.client = `${mod(context, 'uuid')}.uuid4`;
+                result.factory = `${mod(context, 'uuid')}.uuid4`;
+                if (value.version !== undefined && value.version !== 4) {
+                    context.warnings.push(`${label}: the UUID version ${String(value.version)} default was written as uuid.uuid4.`);
+                }
+                break;
+            case 'enumValue': {
+                const info = enumOf(context, field);
+                const position = info?.definition.values.findIndex((entry) => entry.name === value.value) ?? -1;
+                const member = info?.definition.values[position];
+                if (info !== undefined && member !== undefined) {
+                    result.server = pyString(member.dbValue);
+                    result.literal = `${info.className}.${info.memberNames[position] ?? member.name}`;
+                }
+                else {
+                    context.warnings.push(`${label}: the enum default ${value.value} is not a member of the enum and was dropped.`);
+                }
+                break;
+            }
+            case 'literal':
+                Object.assign(result, literalDefault(context, model, field, value.value));
+                break;
+            case 'dbExpression':
+                if (value.isFunction === true) {
+                    context.warnings.push(`${label}: the Prisma default function ${value.expression} has no equivalent here and was dropped.`);
+                }
+                else {
+                    result.server = call(sa(context, 'text'), [
+                        pyString(value.expression),
+                    ]);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    if (field.isAutoUpdated) {
+        result.onUpdate = nowExpression(context, field);
+        if (result.server === undefined && result.client === undefined) {
+            result.client = nowExpression(context, field);
+        }
+    }
+    return result;
+}
+const ACTIONS = {
+    cascade: 'CASCADE',
+    setNull: 'SET NULL',
+    restrict: 'RESTRICT',
+    noAction: 'NO ACTION',
+    setDefault: 'SET DEFAULT',
+};
+function foreignKeyNode(context, spec) {
+    const args = [pyString(spec.target)];
+    args.push(`ondelete=${pyString(ACTIONS[spec.onDelete])}`);
+    if (spec.onUpdate !== undefined) {
+        args.push(`onupdate=${pyString(ACTIONS[spec.onUpdate])}`);
+    }
+    if (spec.name !== undefined) {
+        args.push(`name=${pyString(spec.name)}`);
+    }
+    return call(sa(context, 'ForeignKey'), args);
+}
+function hasSingleKey(model) {
+    return (model.compositePrimaryKey === undefined &&
+        model.primaryKeyName === undefined);
+}
+function modelHasPrimaryKey(model) {
+    return ((model.compositePrimaryKey?.length ?? 0) > 0 ||
+        model.fields.some((field) => field.isPrimaryKey) ||
+        model.relations.some((relation) => relation.isPrimaryKey === true));
+}
+function scalarColumn(context, info, field) {
+    const model = info.model;
+    const label = `${model.name}.${field.name}`;
+    let type = columnType(context, model, field);
+    if (field.generated !== undefined) {
+        context.warnings.push(`${label}: the computed column expression ${field.generated.expression} is not SQL and was dropped; the column was written as a plain column.`);
+    }
+    const isAutoKey = field.default?.kind === 'autoIncrement' &&
+        (field.type === 'int' || field.type === 'bigInt');
+    const singlePrimary = field.isPrimaryKey && hasSingleKey(model);
+    if (field.type === 'bigInt' && isAutoKey && field.isPrimaryKey) {
+        // SQLite only counts up an INTEGER PRIMARY KEY.
+        type = {
+            ...type,
+            sa: call('BigInteger().with_variant', ['Integer', '"sqlite"']),
+        };
+        type.uses.sa.add('BigInteger').add('Integer');
+    }
+    if (field.default?.kind === 'autoIncrement' && !field.isPrimaryKey) {
+        context.warnings.push(`${label}: an auto-increment default on a column that is not the primary key has no equivalent here and was dropped.`);
+    }
+    let autoincrement;
+    if (isAutoKey && field.isPrimaryKey) {
+        autoincrement = singlePrimary ? true : undefined;
+    }
+    else if (field.isPrimaryKey &&
+        (field.type === 'int' || field.type === 'bigInt') &&
+        (model.compositePrimaryKey === undefined ||
+            model.compositePrimaryKey.length === 0)) {
+        autoincrement = false;
+    }
+    return {
+        attr: info.fieldAttrs.get(field.name) ?? field.name,
+        name: field.columnName,
+        type,
+        isNullable: field.isNullable && !field.isPrimaryKey,
+        primaryKey: singlePrimary,
+        autoincrement,
+        isUnique: field.isUnique && !field.isPrimaryKey && field.uniqueName === undefined,
+        defaults: defaultOf(context, model, field),
+        foreignKey: undefined,
+    };
+}
+function relationColumn(context, info, relation) {
+    const link = context.links.find((candidate) => candidate.owner === info &&
+        candidate.name === relation.name &&
+        candidate.kind !== 'manyToMany');
+    const target = link?.target;
+    const key = target === undefined || relation.kind === 'manyToMany'
+        ? undefined
+        : resolveKey(context, target.model.name, relation.toField);
+    const type = keyColumnType(context, info.model, key);
+    let onDelete = relation.onDelete;
+    if (onDelete === 'setNull' && !relation.isNullable) {
+        context.warnings.push(`${info.model.name}.${relation.name}: onDelete SetNull needs a nullable column; it was written as RESTRICT.`);
+        onDelete = 'restrict';
+    }
+    const asKey = isKeyRelation(info.model, relation);
+    const foreignKey = link === undefined
+        ? undefined
+        : {
+            target: `${link.target.model.tableName}.${link.remoteColumns[0] ?? 'id'}`,
+            onDelete,
+            onUpdate: relation.onUpdate,
+            name: relation.constraintName,
+        };
+    return {
+        attr: info.columnAttrs.get(relation.name) ?? relation.columnName,
+        name: relation.columnName,
+        type,
+        isNullable: relation.isNullable && !asKey,
+        primaryKey: relation.isPrimaryKey === true &&
+            hasSingleKey(info.model) &&
+            info.model.fields.every((field) => !field.isPrimaryKey),
+        autoincrement: undefined,
+        isUnique: relation.kind === 'oneToOne' && relation.isPrimaryKey !== true && !asKey,
+        defaults: {},
+        foreignKey,
+    };
+}
+// ---------------------------------------------------------------------------
+// Rendering of a column: SQLAlchemy style
+// ---------------------------------------------------------------------------
+function annotationOf(context, column, nullable) {
+    return nullable ? optional(context, column.type.py) : column.type.py;
+}
+/** `name=value`, keeping a long call as the value breakable. */
+function keyword(name, value) {
+    return typeof value === 'string'
+        ? `${name}=${value}`
+        : group(`${name}=${value.open}`, value.items, value.close);
+}
+function serverDefaultArgument(server) {
+    return keyword('server_default', server);
+}
+function sqlAlchemyColumn(context, column) {
+    const args = [];
+    if (column.attr !== column.name) {
+        args.push(pyString(column.name));
+    }
+    commitTypes(context, column.type);
+    args.push(column.type.sa);
+    if (column.foreignKey !== undefined) {
+        args.push(foreignKeyNode(context, column.foreignKey));
+    }
+    if (column.primaryKey) {
+        args.push('primary_key=True');
+    }
+    if (column.autoincrement !== undefined) {
+        args.push(`autoincrement=${column.autoincrement ? 'True' : 'False'}`);
+    }
+    if (column.isUnique) {
+        args.push('unique=True');
+    }
+    if (column.defaults.client !== undefined) {
+        args.push(`default=${flat(column.defaults.client)}`);
+    }
+    if (column.defaults.server !== undefined) {
+        args.push(serverDefaultArgument(column.defaults.server));
+    }
+    if (column.defaults.onUpdate !== undefined) {
+        args.push(`onupdate=${flat(column.defaults.onUpdate)}`);
+    }
+    const annotation = `${framework(context, 'Mapped')}[${annotationOf(context, column, column.isNullable)}]`;
+    return statement(call(`${column.attr}: ${annotation} = ${framework(context, 'mapped_column')}`, args), 1);
+}
+// ---------------------------------------------------------------------------
+// Rendering of a column: SQLModel style
+// ---------------------------------------------------------------------------
+function isPlainAction(action) {
+    return action === 'cascade' || action === 'setNull' || action === 'restrict';
+}
+function sqlModelColumn(context, column) {
+    const fk = column.foreignKey;
+    // `Field` knows foreign_key and ondelete, but not onupdate, a constraint name or NO ACTION.
+    const needsColumn = fk !== undefined &&
+        (fk.onUpdate !== undefined ||
+            fk.name !== undefined ||
+            !isPlainAction(fk.onDelete));
+    const args = [];
+    // What the constructor sees, and the nullability SQLModel derives from it.
+    let defaultIsNone = false;
+    if (column.defaults.factory !== undefined) {
+        args.push(`default_factory=${column.defaults.factory}`);
+    }
+    else if (column.defaults.literal !== undefined) {
+        args.push(`default=${column.defaults.literal}`);
+    }
+    else if (column.isNullable ||
+        (column.primaryKey && column.autoincrement === true) ||
+        column.defaults.server !== undefined ||
+        column.defaults.client !== undefined ||
+        column.defaults.onUpdate !== undefined) {
+        // The column is optional, or the database (or the ORM) fills the value in.
+        args.push('default=None');
+        defaultIsNone = true;
+    }
+    const derivedNullable = !column.primaryKey && defaultIsNone;
+    const optionalAnnotation = defaultIsNone || column.isNullable;
+    if (needsColumn && fk !== undefined) {
+        commitTypes(context, column.type);
+        const parts = [
+            pyString(column.name),
+            column.type.sa,
+            foreignKeyNode(context, fk),
+        ];
+        if (column.primaryKey) {
+            parts.push('primary_key=True');
+        }
+        parts.push(`nullable=${column.isNullable ? 'True' : 'False'}`);
+        if (column.isUnique) {
+            parts.push('unique=True');
+        }
+        if (column.defaults.client !== undefined &&
+            column.defaults.factory === undefined) {
+            parts.push(`default=${flat(column.defaults.client)}`);
+        }
+        if (column.defaults.server !== undefined) {
+            parts.push(serverDefaultArgument(column.defaults.server));
+        }
+        if (column.defaults.onUpdate !== undefined) {
+            parts.push(`onupdate=${flat(column.defaults.onUpdate)}`);
+        }
+        args.push(call(`sa_column=${sa(context, 'Column')}`, parts));
+    }
+    else {
+        if (column.primaryKey) {
+            args.push('primary_key=True');
+        }
+        if (fk !== undefined) {
+            args.push(`foreign_key=${pyString(fk.target)}`, `ondelete=${pyString(ACTIONS[fk.onDelete])}`);
+        }
+        if (!column.primaryKey && derivedNullable !== column.isNullable) {
+            args.push(`nullable=${column.isNullable ? 'True' : 'False'}`);
+        }
+        if (column.isUnique) {
+            args.push('unique=True');
+        }
+        args.push(...column.type.fieldArgs);
+        if (column.type.needsSaType) {
+            commitTypes(context, column.type);
+            args.push(keyword('sa_type', column.type.sa));
+        }
+        const kwargs = [];
+        if (column.name !== column.attr) {
+            kwargs.push(`"name": ${pyString(column.name)}`);
+        }
+        if (column.autoincrement === false) {
+            kwargs.push('"autoincrement": False');
+        }
+        if (column.defaults.client !== undefined &&
+            column.defaults.factory === undefined) {
+            kwargs.push(`"default": ${flat(column.defaults.client)}`);
+        }
+        if (column.defaults.server !== undefined) {
+            kwargs.push(`"server_default": ${flat(column.defaults.server)}`);
+        }
+        if (column.defaults.onUpdate !== undefined) {
+            kwargs.push(`"onupdate": ${flat(column.defaults.onUpdate)}`);
+        }
+        if (kwargs.length > 0) {
+            args.push(group('sa_column_kwargs={', kwargs, '}'));
+        }
+    }
+    const annotation = annotationOf(context, column, optionalAnnotation);
+    if (args.length === 0) {
+        return `${INDENT}${column.attr}: ${annotation}`;
+    }
+    framework(context, 'Field');
+    return statement(call(`${column.attr}: ${annotation} = Field`, args), 1);
+}
+// ---------------------------------------------------------------------------
+// Relationships
+// ---------------------------------------------------------------------------
+function columnListExpression(info, attrs) {
+    return `[${attrs.map((attr) => `${info.className}.${attr}`).join(', ')}]`;
+}
+function relationshipArguments(context, link, side) {
+    const kwargs = [];
+    const back = side === 'forward' ? link.reverseAttr : link.forwardAttr;
+    if (link.association !== undefined) {
+        const association = link.association;
+        kwargs.push(`secondary=${association.variable}`);
+        if (link.selfReference) {
+            const from = side === 'forward' ? association.ownerColumn : association.targetColumn;
+            const to = side === 'forward' ? association.targetColumn : association.ownerColumn;
+            const keyAttr = association.ownerKey?.attr ?? 'id';
+            const cls = link.owner.className;
+            kwargs.push(`primaryjoin=lambda: ${cls}.${keyAttr} == ${association.variable}.c.${from}`, `secondaryjoin=lambda: ${cls}.${keyAttr} == ${association.variable}.c.${to}`);
+        }
+        return orderKwargs(context, back, kwargs);
+    }
+    if (link.ambiguous) {
+        kwargs.push(`foreign_keys=${pyString(columnListExpression(link.owner, link.localAttrs))}`);
+    }
+    if (side === 'forward' && link.selfReference) {
+        kwargs.push(`remote_side=${pyString(link.remoteAttrs.length === 1 ? `${link.target.className}.${link.remoteAttrs[0] ?? 'id'}` : columnListExpression(link.target, link.remoteAttrs))}`);
+    }
+    if (side === 'reverse' &&
+        (link.onDelete === 'cascade' || link.onDelete === 'setNull')) {
+        kwargs.push('passive_deletes=True');
+    }
+    return orderKwargs(context, back, kwargs);
+}
+function orderKwargs(_context, back, kwargs) {
+    return [`back_populates=${pyString(back)}`, ...kwargs];
+}
+function relationshipStatement(context, link, side) {
+    const attr = side === 'forward' ? link.forwardAttr : link.reverseAttr;
+    const targetClass = side === 'forward' ? link.target.className : link.owner.className;
+    const collection = link.kind === 'manyToMany' ||
+        (side === 'reverse' && link.kind === 'foreignKey');
+    const nullable = side === 'forward'
+        ? link.isNullable && link.kind !== 'manyToMany'
+        : link.kind === 'oneToOne';
+    const reference = pyString(targetClass);
+    const annotation = collection
+        ? `list[${reference}]`
+        : nullable
+            ? optional(context, reference)
+            : reference;
+    const args = relationshipArguments(context, link, side);
+    if (context.style === 'sqlmodel') {
+        const direct = [args[0] ?? ''];
+        const extra = args.slice(1).map((entry) => {
+            const text = flat(entry);
+            const separator = text.indexOf('=');
+            const name = text.slice(0, separator);
+            return `${pyString(name)}: ${text.slice(separator + 1)}`;
+        });
+        if (extra.length > 0) {
+            direct.push(group('sa_relationship_kwargs={', extra, '}'));
+        }
+        framework(context, 'Relationship');
+        return statement(call(`${attr}: ${annotation} = Relationship`, direct), 1);
+    }
+    const mappedAnnotation = `${framework(context, 'Mapped')}[${annotation}]`;
+    return statement(call(`${attr}: ${mappedAnnotation} = ${framework(context, 'relationship')}`, args), 1);
+}
+// ---------------------------------------------------------------------------
+// Constraints and indexes
+// ---------------------------------------------------------------------------
+function columnNameOf(info, name) {
+    const field = info.model.fields.find((candidate) => candidate.name === name);
+    if (field !== undefined) {
+        return [field.columnName];
+    }
+    const relation = info.model.relations.find((candidate) => candidate.kind !== 'manyToMany' && candidate.name === name);
+    if (relation !== undefined) {
+        return [relation.columnName];
+    }
+    const composite = (info.model.compositeForeignKeys ?? []).find((candidate) => candidate.name === name);
+    if (composite !== undefined) {
+        return composite.fields.flatMap((fieldName) => columnNameOf(info, fieldName));
+    }
+    return [name];
+}
+function tableArguments(context, info) {
+    const model = info.model;
+    const items = [];
+    if (!hasSingleKey(model) && modelHasPrimaryKey(model)) {
+        const keyNames = model.compositePrimaryKey ?? [
+            ...model.fields
+                .filter((field) => field.isPrimaryKey)
+                .map((field) => field.name),
+            ...model.relations
+                .filter((relation) => relation.isPrimaryKey === true)
+                .map((relation) => relation.name),
+        ];
+        const columns = keyNames.flatMap((name) => columnNameOf(info, name));
+        const args = columns.map(pyString);
+        if (model.primaryKeyName !== undefined) {
+            args.push(`name=${pyString(model.primaryKeyName)}`);
+        }
+        items.push(call(sa(context, 'PrimaryKeyConstraint'), args));
+    }
+    for (const link of context.links) {
+        if (link.owner !== info || !link.composite) {
+            continue;
+        }
+        const args = [
+            group('[', link.localColumns.map(pyString), ']'),
+            group('[', link.remoteColumns.map((column) => pyString(`${link.target.model.tableName}.${column}`)), ']'),
+        ];
+        if (link.constraintName !== undefined) {
+            args.push(`name=${pyString(link.constraintName)}`);
+        }
+        args.push(`ondelete=${pyString(ACTIONS[link.onDelete])}`);
+        if (link.onUpdate !== undefined) {
+            args.push(`onupdate=${pyString(ACTIONS[link.onUpdate])}`);
+        }
+        items.push(call(sa(context, 'ForeignKeyConstraint'), args));
+    }
+    for (const field of model.fields) {
+        if (field.isUnique &&
+            !field.isPrimaryKey &&
+            field.uniqueName !== undefined) {
+            const name = field.uniqueName;
+            context.constraintNames.add(name);
+            items.push(call(sa(context, 'UniqueConstraint'), [
+                pyString(field.columnName),
+                `name=${pyString(name)}`,
+            ]));
+        }
+    }
+    for (const index of model.indexes) {
+        items.push(indexNode(context, info, index));
+    }
+    return items;
+}
+function indexNode(context, info, index) {
+    const columns = index.fields.flatMap((name) => columnNameOf(info, name));
+    const table = info.model.tableName;
+    const prefix = index.isUnique ? 'uq' : 'ix';
+    const requested = index.name ?? `${prefix}_${table}_${columns.join('_')}`;
+    const name = uniqueName(limitIdentifier(requested, 63), context.constraintNames);
+    if (index.isUnique) {
+        return call(sa(context, 'UniqueConstraint'), [
+            ...columns.map(pyString),
+            `name=${pyString(name)}`,
+        ]);
+    }
+    return call(sa(context, 'Index'), [pyString(name), ...columns.map(pyString)]);
+}
+// ---------------------------------------------------------------------------
+// Classes
+// ---------------------------------------------------------------------------
+function renderClass(context, info) {
+    const model = info.model;
+    const lines = [];
+    lines.push(context.style === 'sqlmodel'
+        ? `class ${info.className}(SQLModel, table=True):`
+        : `class ${info.className}(Base):`);
+    lines.push(`${INDENT}__tablename__ = ${pyString(model.tableName)}`);
+    const tableArgs = tableArguments(context, info);
+    const hasKey = modelHasPrimaryKey(model);
+    const columns = [];
+    for (const field of model.fields) {
+        columns.push(scalarColumn(context, info, field));
+    }
+    const foreignColumns = [];
+    for (const relation of model.relations) {
+        if (relation.kind === 'manyToMany') {
+            continue;
+        }
+        foreignColumns.push(relationColumn(context, info, relation));
+    }
+    const postgresOnly = model.fields
+        .filter((field) => (field.arrayDepth ?? 0) > 0 ||
+        field.type === 'hstore' ||
+        field.type === 'range' ||
+        field.type === 'ipAddress')
+        .map((field) => field.name);
+    if (postgresOnly.length > 0) {
+        context.warnings.push(`${model.name}.${postgresOnly.join(', ')}: array, HSTORE, range and IP address columns are PostgreSQL types; they fall back to JSON (or a string) on SQLite.`);
+    }
+    if (!hasKey) {
+        context.warnings.push(`${model.name}: the table has no primary key, which ${context.style === 'sqlmodel' ? 'SQLModel' : 'the SQLAlchemy ORM'} requires; ${context.style === 'sqlmodel' ? 'the first column was marked as the primary key' : 'every required column was declared as the mapper key (the table itself keeps no primary key)'}.`);
+    }
+    const mapperKey = [];
+    const all = [...columns, ...foreignColumns];
+    if (!hasKey && all.length > 0) {
+        if (context.style === 'sqlmodel') {
+            const first = all[0];
+            if (first !== undefined) {
+                first.primaryKey = true;
+            }
+        }
+        else {
+            const required = all.filter((column) => !column.isNullable);
+            for (const column of required.length > 0 ? required : all) {
+                mapperKey.push(column.attr);
+            }
+        }
+    }
+    const body = [];
+    for (const column of all) {
+        body.push(context.style === 'sqlmodel'
+            ? sqlModelColumn(context, column)
+            : sqlAlchemyColumn(context, column));
+    }
+    const relationships = [];
+    for (const link of context.links) {
+        if (link.owner === info) {
+            relationships.push(relationshipStatement(context, link, 'forward'));
+        }
+    }
+    for (const link of info.incoming) {
+        relationships.push(relationshipStatement(context, link, 'reverse'));
+    }
+    if (tableArgs.length > 0) {
+        lines.push(statement({
+            open: '__table_args__ = (',
+            items: tableArgs,
+            close: ')',
+            force: true,
+        }, 1));
+    }
+    if (mapperKey.length > 0) {
+        lines.push(`${INDENT}__mapper_args__ = {"primary_key": [${mapperKey.join(', ')}]}`);
+    }
+    lines.push('');
+    lines.push(...body);
+    if (relationships.length > 0) {
+        lines.push('', ...relationships);
+    }
+    if (body.length === 0 && relationships.length === 0) {
+        lines.push(`${INDENT}pass`);
+    }
+    while (lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines.join('\n');
+}
+function renderAssociation(context, association) {
+    const key = (column, resolved, table) => {
+        const target = `${table ?? 'unknown'}.${resolved?.columnName ?? 'id'}`;
+        return call(sa(context, 'Column'), [
+            pyString(column),
+            call(sa(context, 'ForeignKey'), [pyString(target), 'ondelete="CASCADE"']),
+            'primary_key=True',
+        ]);
+    };
+    const link = context.links.find((candidate) => candidate.association === association);
+    const node = call(`${association.variable} = ${sa(context, 'Table')}`, [
+        pyString(association.tableName),
+        metadataExpression(context),
+        key(association.ownerColumn, association.ownerKey, link?.owner.model.tableName),
+        key(association.targetColumn, association.targetKey, link?.target.model.tableName),
+    ]);
+    return statement(node, 0);
+}
+function renderView(context, model) {
+    context.warnings.push(`${model.name}: this is a database view; SQLAlchemy has no declarative view, so it was written as a comment. Create the view in the database and reflect it (Table(${pyString(model.tableName)}, ${metadataExpression(context)}, autoload_with=engine)).`);
+    const lines = [
+        `# View ${model.name} (${model.tableName}) is not mapped: SQLAlchemy has no declarative view construct.`,
+        `# Create the view in the database, then reflect it with`,
+        `#     Table(${pyString(model.tableName)}, ${metadataExpression(context)}, autoload_with=engine)`,
+        `# Columns: ${model.fields.map((field) => field.columnName).join(', ') || '(none)'}`,
+    ];
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------
+function importLine(module, names) {
+    // isort's default: CONSTANTS first, then Classes, then functions.
+    const rank = (name) => /^[A-Z0-9_]+$/.test(name) && name.length > 1
+        ? 0
+        : /^[A-Z]/.test(name)
+            ? 1
+            : 2;
+    const sorted = [...names].sort((first, second) => rank(first) - rank(second) || first.localeCompare(second, 'en'));
+    const inline = `from ${module} import ${sorted.join(', ')}`;
+    if (inline.length <= MAX_LINE_WIDTH) {
+        return inline;
+    }
+    return `from ${module} import (\n${sorted.map((name) => `${INDENT}${name},`).join('\n')}\n)`;
+}
+function buildImports(context) {
+    const standard = [...context.modules]
+        .sort()
+        .map((name) => `import ${name}`);
+    if (context.typingImports.size > 0) {
+        standard.push(importLine('typing', [...context.typingImports]));
+    }
+    const thirdParty = [];
+    if (context.saImports.size > 0) {
+        thirdParty.push(importLine('sqlalchemy', [...context.saImports]));
+    }
+    if (context.pgImports.size > 0) {
+        thirdParty.push(importLine('sqlalchemy.dialects.postgresql', [...context.pgImports]));
+    }
+    if (context.style === 'sqlalchemy') {
+        if (context.frameworkImports.size > 0) {
+            thirdParty.push(importLine('sqlalchemy.orm', [...context.frameworkImports]));
+        }
+    }
+    else {
+        const names = new Set(context.frameworkImports);
+        names.add('SQLModel');
+        thirdParty.push(importLine('sqlmodel', [...names]));
+    }
+    return [standard.join('\n'), thirdParty.join('\n')]
+        .filter((block) => block !== '')
+        .join('\n\n');
+}
+//# sourceMappingURL=sqlalchemy.js.map