ormbridge 0.7.0 → 0.8.0

package/dist/emitters/sequelize.js

@@ -0,0 +1,1276 @@
+import { findModel } from '../ir.js';
+import { toCamelCase, toPascalCase, toSnakeCase } from '../naming.js';
+import { underscore } from '../parsers/sequelizeInflection.js';
+import { prismaOnlyWarnings } from '../prismaOnlyConstructs.js';
+import { normalizeSchema } from '../transforms.js';
+export const SEQUELIZE_STYLES = ['init', 'define'];
+/** True when a value is one of the Sequelize `--style` values. */
+export function isSequelizeStyle(value) {
+    return SEQUELIZE_STYLES.includes(value);
+}
+const INDENT = '  ';
+const MAX_LINE_WIDTH = 80;
+const IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const CREATED_FIELD_PATTERN = /^(created_?at|created|date_?created|createdon)$/i;
+/** Names a generated model file declares or imports, which a class cannot take. */
+const RESERVED_CLASS_NAMES = new Set([
+    'Model',
+    'Sequelize',
+    'DataTypes',
+    'CreationOptional',
+    'InferAttributes',
+    'InferCreationAttributes',
+    'NonAttribute',
+    'Buffer',
+    'Date',
+    'Object',
+    'Array',
+    'Record',
+    'String',
+    'Number',
+    'Boolean',
+    'Models',
+]);
+/** Words an attribute cannot be called on a Sequelize instance without shadowing a member of `Model`. */
+const RESERVED_ATTRIBUTES = new Set([
+    'constructor',
+    'prototype',
+    'sequelize',
+    'dataValues',
+    'isNewRecord',
+]);
+const ON_ACTIONS = {
+    cascade: 'CASCADE',
+    setNull: 'SET NULL',
+    restrict: 'RESTRICT',
+    noAction: 'NO ACTION',
+    setDefault: 'SET DEFAULT',
+};
+/** The index method the IR spells like Prisma, as Sequelize's `using` writes it. */
+const INDEX_METHODS = {
+    btree: 'BTREE',
+    hash: 'HASH',
+    gin: 'GIN',
+    gist: 'GIST',
+    spgist: 'SPGIST',
+    brin: 'BRIN',
+};
+/** Types Sequelize can name for a column the IR calls `unsupported`, by the database type it read. */
+const POSTGRES_ONLY_TYPES = {
+    geometry: 'GEOMETRY',
+    geography: 'GEOGRAPHY',
+    cidr: 'CIDR',
+    macaddr: 'MACADDR',
+    tsvector: 'TSVECTOR',
+    citext: 'CITEXT',
+};
+const RANGE_SUBTYPES = {
+    int: 'INTEGER',
+    bigInt: 'BIGINT',
+    decimal: 'DECIMAL',
+    date: 'DATEONLY',
+    dateTime: 'DATE',
+};
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+export function emitSequelize(schema, options) {
+    const prepared = options.naming === 'normalize' ? normalizeSchema(schema) : schema;
+    const style = options.style ?? 'init';
+    const context = {
+        schema: prepared,
+        options,
+        style,
+        dialect: dialectOf(options.provider),
+        warnings: prismaOnlyWarnings(prepared, true).filter(isUnhandledWarning),
+        plans: new Map(),
+        inverseAliases: new Map(),
+        usesLiteral: false,
+    };
+    if (options.provider === 'mongodb') {
+        context.warnings.push('Provider "mongodb": Sequelize is relational (it has no MongoDB dialect; use Mongoose); PostgreSQL column types were written.');
+    }
+    const files = {};
+    if (prepared.models.length === 0) {
+        return { files, warnings: context.warnings };
+    }
+    planModels(context);
+    planInverseAliases(context);
+    const associations = {
+        byOwner: new Map(),
+        ordered: [],
+    };
+    const extension = style === 'init' ? 'ts' : 'js';
+    const rendered = new Map();
+    for (const model of prepared.models) {
+        context.usesLiteral = false;
+        rendered.set(model.name, renderModel(context, planOf(context, model), associations));
+    }
+    for (const model of prepared.models) {
+        const plan = planOf(context, model);
+        const result = rendered.get(model.name);
+        if (result === undefined) {
+            continue;
+        }
+        files[`${plan.fileBase}.${extension}`] =
+            style === 'init'
+                ? writeInitFile(context, plan, result, associations)
+                : writeDefineFile(plan, result, associations);
+    }
+    files[`index.${extension}`] =
+        style === 'init'
+            ? writeInitIndex(context, associations)
+            : writeDefineIndex(context);
+    return { files, warnings: context.warnings };
+}
+/** Drops the Prisma-only notes for things this emitter writes (schemas, defaults, actions, index details). */
+function isUnhandledWarning(warning) {
+    if (warning.includes('the onUpdate action')) {
+        return false;
+    }
+    if (warning.includes('the database default expression')) {
+        return false;
+    }
+    if (warning.includes('(Prisma Unsupported)')) {
+        return false;
+    }
+    if (warning.includes('is generated by Prisma Client and was dropped')) {
+        return false;
+    }
+    if (warning.includes('full-text indexes are not supported here')) {
+        return false;
+    }
+    if (warning.includes('the index type, clustering')) {
+        return false;
+    }
+    return !(warning.includes('(@@schema) was ignored') && !warning.startsWith('enum '));
+}
+function dialectOf(provider) {
+    switch (provider) {
+        case 'mysql':
+            return 'mysql';
+        case 'sqlite':
+            return 'sqlite';
+        case 'sqlserver':
+            return 'mssql';
+        default:
+            return 'postgres';
+    }
+}
+// ---------------------------------------------------------------------------
+// Small helpers
+// ---------------------------------------------------------------------------
+function quote(value) {
+    const escaped = value
+        .replace(/\\/g, '\\\\')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r');
+    if (value.includes("'") && !value.includes('"')) {
+        return `"${escaped}"`;
+    }
+    return `'${escaped.replace(/'/g, "\\'")}'`;
+}
+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 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 JavaScript identifier; it was written as "${result}".`);
+    return result;
+}
+function compact(entries) {
+    return entries.filter((entry) => entry !== undefined);
+}
+/** `{ a, b }` on one line when it fits after `prefix`, otherwise one entry per line. */
+function objectLines(prefix, entries, indent, suffix) {
+    const inline = `${indent}${prefix}{ ${entries.join(', ')} }${suffix}`;
+    if (entries.length === 0) {
+        return [`${indent}${prefix}{}${suffix}`];
+    }
+    if (inline.length <= MAX_LINE_WIDTH) {
+        return [inline];
+    }
+    return [
+        `${indent}${prefix}{`,
+        ...entries.map((entry) => `${indent}${INDENT}${entry},`),
+        `${indent}}${suffix}`,
+    ];
+}
+function isIntegerKey(field) {
+    return field.type === 'int' || field.type === 'bigInt';
+}
+function planOf(context, model) {
+    const plan = context.plans.get(model.name);
+    if (plan === undefined) {
+        throw new Error(`No plan exists for the model "${model.name}".`);
+    }
+    return plan;
+}
+function enumOf(context, field) {
+    return field.enumName === undefined
+        ? undefined
+        : context.schema.enums.find((candidate) => candidate.name === field.enumName);
+}
+function enumMember(enumeration, raw) {
+    return (enumeration.values.find((value) => value.name === raw) ??
+        enumeration.values.find((value) => value.dbValue === raw));
+}
+// ---------------------------------------------------------------------------
+// Planning: names, timestamps, key-like columns
+// ---------------------------------------------------------------------------
+function keyLikeFields(context, model) {
+    const keyed = new Set();
+    for (const field of model.fields) {
+        if (field.isPrimaryKey || field.isUnique) {
+            keyed.add(field.name);
+        }
+    }
+    for (const name of model.compositePrimaryKey ?? []) {
+        keyed.add(name);
+    }
+    for (const index of model.indexes) {
+        for (const name of index.fields) {
+            keyed.add(name);
+        }
+    }
+    for (const other of context.schema.models) {
+        for (const relation of other.relations) {
+            if (relation.targetModel === model.name && relation.toField) {
+                keyed.add(relation.toField);
+            }
+        }
+    }
+    return keyed;
+}
+function attributeName(context, model, rawName) {
+    const styled = context.options.naming === 'normalize' ? toCamelCase(rawName) : rawName;
+    const safe = identifier(context, `${model.name}.${rawName}`, styled === '' ? rawName : styled);
+    return RESERVED_ATTRIBUTES.has(safe) ? `${safe}_` : safe;
+}
+/** `underscored` is the setting under which the most attribute names already map onto their column names. */
+function chooseUnderscored(context, model, attrs) {
+    if (context.options.naming === 'normalize') {
+        return true;
+    }
+    let underscored = 0;
+    let plain = 0;
+    for (const field of model.fields) {
+        const attr = attrs.get(field.name) ?? field.name;
+        const snake = underscore(attr) === field.columnName;
+        const same = attr === field.columnName;
+        if (snake && !same) {
+            underscored += 1;
+        }
+        else if (same && !snake) {
+            plain += 1;
+        }
+    }
+    return underscored > plain;
+}
+function planModels(context) {
+    const fileBases = new Set(['index']);
+    const classNames = new Set(RESERVED_CLASS_NAMES);
+    for (const model of context.schema.models) {
+        // Sequelize model names are PascalCase; `legacy_order` is written as `LegacyOrder`.
+        const pascal = /^[A-Z][A-Za-z0-9]*$/.test(model.name)
+            ? model.name
+            : toPascalCase(model.name);
+        const rawClass = identifier(context, model.name, pascal === '' ? model.name : pascal);
+        const className = uniqueName(RESERVED_CLASS_NAMES.has(rawClass) ? `${rawClass}Model` : rawClass, classNames);
+        if (RESERVED_CLASS_NAMES.has(rawClass)) {
+            context.warnings.push(`${model.name}: "${rawClass}" is a name the generated files use, so the class and the model were named "${className}".`);
+        }
+        const base = toCamelCase(className) || 'model';
+        const used = new Set();
+        const attrs = new Map();
+        for (const field of model.fields) {
+            attrs.set(field.name, uniqueName(attributeName(context, model, field.name), used));
+        }
+        const keys = new Map();
+        const aliases = new Map();
+        for (const relation of model.relations) {
+            if (relation.kind === 'manyToMany') {
+                continue;
+            }
+            keys.set(relation.name, uniqueName(attributeName(context, model, relation.columnName), used));
+        }
+        for (const relation of model.relations) {
+            aliases.set(relation.name, uniqueName(attributeName(context, model, relation.name), used));
+        }
+        const plan = {
+            model,
+            className,
+            fileBase: uniqueName(base, fileBases),
+            underscored: chooseUnderscored(context, model, attrs),
+            attrs,
+            keys,
+            aliases,
+            used,
+            timestamps: {},
+            keyLike: keyLikeFields(context, model),
+        };
+        plan.timestamps = planTimestamps(plan);
+        context.plans.set(model.name, plan);
+    }
+}
+/** The column Sequelize derives for an attribute. */
+function derivedColumn(plan, attribute) {
+    return plan.underscored ? underscore(attribute) : attribute;
+}
+/** Finds the fields that Sequelize's `createdAt` and `updatedAt` options can stand for. */
+function planTimestamps(plan) {
+    const model = plan.model;
+    const composite = new Set(model.compositePrimaryKey ?? []);
+    const eligible = (field) => field.type === 'dateTime' &&
+        !field.isPrimaryKey &&
+        !composite.has(field.name) &&
+        field.arrayDepth === undefined &&
+        field.generated === undefined;
+    const created = model.fields.find((field) => eligible(field) &&
+        !field.isAutoUpdated &&
+        CREATED_FIELD_PATTERN.test(field.name));
+    const updated = model.fields.find((field) => eligible(field) && field.isAutoUpdated);
+    return {
+        ...(created === undefined ? {} : { created }),
+        ...(updated === undefined ? {} : { updated }),
+    };
+}
+/**
+ * True when Sequelize can add the column itself: the attribute is not written because `timestamps`
+ * creates exactly that column. A nullable column, one with another default or a unique flag, or one whose
+ * name `underscored` does not derive is declared next to the option instead.
+ */
+function isImplicitTimestamp(plan, field, kind) {
+    const attr = plan.attrs.get(field.name) ?? field.name;
+    const defaultOk = field.default === undefined ||
+        (kind === 'created' && field.default.kind === 'now');
+    return (defaultOk &&
+        !field.isNullable &&
+        !field.isUnique &&
+        field.enumName === undefined &&
+        derivedColumn(plan, attr) === field.columnName);
+}
+function planInverseAliases(context) {
+    for (const model of context.schema.models) {
+        for (const relation of model.relations) {
+            if (relation.relatedName === undefined) {
+                continue;
+            }
+            const target = findModel(context.schema, relation.targetModel);
+            if (target === undefined) {
+                continue;
+            }
+            const targetPlan = planOf(context, target);
+            const safe = identifier(context, `${model.name}.${relation.name}`, context.options.naming === 'normalize'
+                ? toCamelCase(relation.relatedName)
+                : relation.relatedName);
+            context.inverseAliases.set(`${model.name}.${relation.name}`, uniqueName(safe, targetPlan.used));
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Column types
+// ---------------------------------------------------------------------------
+function typeSpecOf(context, label, field, keyLike) {
+    const depth = field.arrayDepth ?? 0;
+    if (depth === 0) {
+        return scalarTypeSpec(context, label, field, keyLike);
+    }
+    const element = scalarTypeSpec(context, label, { ...field, arrayDepth: undefined }, keyLike);
+    const ts = `${element.ts.includes(' ') ? `(${element.ts})` : element.ts}${'[]'.repeat(depth)}`;
+    if (context.dialect === 'postgres') {
+        let expression = element.expression;
+        for (let level = 0; level < depth; level += 1) {
+            expression = `DataTypes.ARRAY(${expression})`;
+        }
+        return { expression, ts };
+    }
+    const jsonType = jsonTypeOf({ ...context, warnings: [] }, label, 'array');
+    context.warnings.push(`${label}: ${dialectName(context.dialect)} has no array column type; the array was written as ${jsonType.startsWith('DataTypes.JSON') ? 'JSON' : 'TEXT'}.`);
+    return { expression: jsonType, ts };
+}
+function dialectName(dialect) {
+    switch (dialect) {
+        case 'mysql':
+            return 'MySQL';
+        case 'sqlite':
+            return 'SQLite';
+        case 'mssql':
+            return 'SQL Server';
+        default:
+            return 'PostgreSQL';
+    }
+}
+/** JSON where the dialect has it; Sequelize's SQL Server dialect has none, so text holds the document. */
+function jsonTypeOf(context, label, what) {
+    switch (context.dialect) {
+        case 'postgres':
+            return 'DataTypes.JSONB';
+        case 'mssql':
+            context.warnings.push(`${label}: SQL Server has no JSON column type before SQL Server 2025 (Sequelize would create a column of type JSON); the ${what} was written as TEXT.`);
+            return 'DataTypes.TEXT';
+        default:
+            return 'DataTypes.JSON';
+    }
+}
+function scalarTypeSpec(context, label, field, keyLike) {
+    const dialect = context.dialect;
+    if (field.enumName !== undefined) {
+        const enumeration = enumOf(context, field);
+        if (enumeration === undefined) {
+            context.warnings.push(`${label}: enum "${field.enumName}" does not exist in the schema; the column was written as a plain string.`);
+        }
+        else if (dialect === 'mssql') {
+            // Sequelize's SQL Server ENUM is a VARCHAR with a CHECK constraint that leaves out NOT NULL and the default.
+            context.warnings.push(`${label}: Sequelize's ENUM for SQL Server drops NOT NULL and the default; the column was written as STRING and the values are only used for typing.`);
+            return {
+                expression: 'DataTypes.STRING',
+                ts: enumUnion(enumeration),
+            };
+        }
+        else {
+            return {
+                expression: `DataTypes.ENUM(${enumeration.values
+                    .map((value) => quote(value.dbValue))
+                    .join(', ')})`,
+                ts: enumUnion(enumeration),
+            };
+        }
+    }
+    switch (field.type) {
+        case 'string':
+            if (field.maxLength !== undefined) {
+                return {
+                    expression: `DataTypes.STRING(${field.maxLength})`,
+                    ts: 'string',
+                };
+            }
+            // Sequelize has no unbounded varchar: TEXT keeps long values, but cannot be a key in MySQL.
+            return {
+                expression: keyLike ? 'DataTypes.STRING' : 'DataTypes.TEXT',
+                ts: 'string',
+            };
+        case 'text':
+            return { expression: 'DataTypes.TEXT', ts: 'string' };
+        case 'uuid':
+            return { expression: 'DataTypes.UUID', ts: 'string' };
+        case 'int':
+            return { expression: 'DataTypes.INTEGER', ts: 'number' };
+        case 'bigInt':
+            return { expression: 'DataTypes.BIGINT', ts: 'string' };
+        case 'float':
+            return { expression: 'DataTypes.DOUBLE', ts: 'number' };
+        case 'decimal': {
+            const precision = field.maxDigits;
+            const scale = field.decimalPlaces;
+            const args = precision === undefined
+                ? ''
+                : scale === undefined
+                    ? `(${precision})`
+                    : `(${precision}, ${scale})`;
+            return { expression: `DataTypes.DECIMAL${args}`, ts: 'string' };
+        }
+        case 'boolean':
+            return { expression: 'DataTypes.BOOLEAN', ts: 'boolean' };
+        case 'dateTime':
+            return { expression: 'DataTypes.DATE', ts: 'Date' };
+        case 'date':
+            return { expression: 'DataTypes.DATEONLY', ts: 'string' };
+        case 'time':
+            return { expression: 'DataTypes.TIME', ts: 'string' };
+        case 'json':
+            return {
+                expression: jsonTypeOf(context, label, 'column'),
+                ts: 'unknown',
+            };
+        case 'bytes':
+            return { expression: 'DataTypes.BLOB', ts: 'Buffer' };
+        case 'duration':
+            context.warnings.push(`${label}: Sequelize has no interval type; the duration was written as BIGINT (microseconds).`);
+            return { expression: 'DataTypes.BIGINT', ts: 'string' };
+        case 'ipAddress':
+            return dialect === 'postgres'
+                ? { expression: 'DataTypes.INET', ts: 'string' }
+                : { expression: 'DataTypes.STRING(45)', ts: 'string' };
+        case 'hstore':
+            if (dialect === 'postgres') {
+                return {
+                    expression: 'DataTypes.HSTORE',
+                    ts: 'Record<string, string | null>',
+                };
+            }
+            context.warnings.push(`${label}: hstore exists only on PostgreSQL; the field was written as ${dialect === 'mssql' ? 'TEXT' : 'JSON'}.`);
+            return {
+                expression: jsonTypeOf({ ...context, warnings: [] }, label, 'field'),
+                ts: 'Record<string, string | null>',
+            };
+        case 'range': {
+            if (dialect === 'postgres') {
+                const subtype = RANGE_SUBTYPES[field.rangeOf ?? 'int'] ?? 'INTEGER';
+                return {
+                    expression: `DataTypes.RANGE(DataTypes.${subtype})`,
+                    ts: 'unknown',
+                };
+            }
+            context.warnings.push(`${label}: range columns exist only on PostgreSQL; the field was written as TEXT.`);
+            return { expression: 'DataTypes.TEXT', ts: 'string' };
+        }
+        case 'unsupported': {
+            const raw = (field.unsupportedType ?? '').toLowerCase();
+            const known = POSTGRES_ONLY_TYPES[raw];
+            if (known !== undefined && dialect === 'postgres') {
+                return { expression: `DataTypes.${known}`, ts: 'unknown' };
+            }
+            context.warnings.push(`${label}: the database type "${field.unsupportedType ?? 'unknown'}" has no Sequelize data type${known === undefined ? '' : ` on ${dialectName(dialect)}`}; the column was written as TEXT.`);
+            return { expression: 'DataTypes.TEXT', ts: 'string' };
+        }
+        default:
+            context.warnings.push(`${label}: unknown field type "${String(field.type)}"; it was written as TEXT.`);
+            return { expression: 'DataTypes.TEXT', ts: 'string' };
+    }
+}
+function enumUnion(enumeration) {
+    return enumeration.values
+        .map((value) => quote(value.dbValue))
+        .join(' | ');
+}
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+/** The value of `defaultValue` for a field, or undefined when it has none or Sequelize cannot express it. */
+function defaultOf(context, label, field) {
+    const value = field.default;
+    if (value === undefined) {
+        return undefined;
+    }
+    const enumeration = enumOf(context, field);
+    switch (value.kind) {
+        case 'autoIncrement':
+            return undefined;
+        case 'now':
+            return 'DataTypes.NOW';
+        case 'uuid':
+            if (value.version !== undefined && value.version !== 1) {
+                if (value.version !== 4) {
+                    context.warnings.push(`${label}: Sequelize generates UUID versions 1 and 4 only; the version ${value.version} default was written as UUIDV4.`);
+                }
+            }
+            return value.version === 1 ? 'DataTypes.UUIDV1' : 'DataTypes.UUIDV4';
+        case 'enumValue': {
+            const member = enumeration === undefined
+                ? undefined
+                : enumMember(enumeration, value.value);
+            if (member === undefined) {
+                context.warnings.push(`${label}: the enum default "${value.value}" does not match a member of the enum; it was written as a string.`);
+                return quote(value.value);
+            }
+            return quote(member.dbValue);
+        }
+        case 'dbExpression':
+            context.usesLiteral = true;
+            return `Sequelize.literal(${quote(defaultExpression(context, value.expression))})`;
+        case 'clientGenerated':
+            context.warnings.push(`${label}: the ${value.generator}() default is generated by Prisma Client; Sequelize has no equivalent and the default was dropped.`);
+            return undefined;
+        case 'literal':
+            return literalDefault(context, label, field, value.value, enumeration);
+        default:
+            return undefined;
+    }
+}
+function literalDefault(context, label, field, value, enumeration) {
+    if (typeof value !== 'string') {
+        return String(value);
+    }
+    if (enumeration !== undefined) {
+        const member = enumMember(enumeration, value);
+        return quote(member === undefined ? value : member.dbValue);
+    }
+    if ((field.arrayDepth ?? 0) > 0) {
+        if (value === '[]') {
+            return '[]';
+        }
+        context.warnings.push(`${label}: the array default ${value} cannot be written; it was dropped.`);
+        return undefined;
+    }
+    if (field.type === 'json') {
+        try {
+            return jsonLiteral(JSON.parse(value));
+        }
+        catch {
+            return quote(value);
+        }
+    }
+    if (field.type === 'hstore' && value === '{}') {
+        return '{}';
+    }
+    if (field.type === 'bytes') {
+        context.warnings.push(`${label}: a literal default on a binary column cannot be written; it was dropped.`);
+        return undefined;
+    }
+    return quote(value);
+}
+/** An expression default that every dialect reads without parentheses. */
+const PLAIN_DEFAULT = /^(current_(timestamp|date|time)(\(\d*\))?|localtimestamp|now\(\)|null|true|false|-?\d+(\.\d+)?|'(?:[^']|'')*')$/i;
+/** SQLite and MySQL accept an expression as a default only in parentheses: `DEFAULT (uuid())`. */
+function defaultExpression(context, expression) {
+    const trimmed = expression.trim();
+    const needsParentheses = (context.dialect === 'sqlite' || context.dialect === 'mysql') &&
+        !PLAIN_DEFAULT.test(trimmed) &&
+        !/^\(.*\)$/s.test(trimmed);
+    return needsParentheses ? `(${trimmed})` : trimmed;
+}
+function jsonLiteral(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'string') {
+        return quote(value);
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(jsonLiteral).join(', ')}]`;
+    }
+    if (typeof value === 'object') {
+        const parts = Object.entries(value).map(([key, item]) => `${IDENTIFIER_PATTERN.test(key) ? key : quote(key)}: ${jsonLiteral(item)}`);
+        return parts.length === 0 ? '{}' : `{ ${parts.join(', ')} }`;
+    }
+    return 'null';
+}
+// ---------------------------------------------------------------------------
+// Attributes
+// ---------------------------------------------------------------------------
+function columnEntry(plan, attribute, column) {
+    return derivedColumn(plan, attribute) === column
+        ? undefined
+        : `field: ${quote(column)}`;
+}
+function fieldAttribute(context, plan, field) {
+    const model = plan.model;
+    const label = `${model.name}.${field.name}`;
+    const name = plan.attrs.get(field.name) ?? field.name;
+    const spec = typeSpecOf(context, label, field, plan.keyLike.has(field.name));
+    const inCompositeKey = model.compositePrimaryKey?.includes(field.name) ?? false;
+    const isKey = field.isPrimaryKey || inCompositeKey;
+    if (field.generated !== undefined) {
+        context.warnings.push(`${label}: Sequelize has no generated columns, so the expression ${field.generated.expression} was dropped and the column written as a regular one.`);
+    }
+    if (field.isAutoUpdated && plan.timestamps.updated !== field) {
+        context.warnings.push(`${label}: only a date-time column can be Sequelize's updatedAt; it was written as a plain column that the application has to refresh.`);
+    }
+    let autoIncrement = false;
+    if (field.default?.kind === 'autoIncrement') {
+        if (field.isPrimaryKey && !inCompositeKey && isIntegerKey(field)) {
+            autoIncrement = true;
+        }
+        else {
+            context.warnings.push(`${label}: an auto-increment default is only supported on a single integer primary key; it was dropped.`);
+        }
+    }
+    const defaultValue = defaultOf(context, label, field);
+    const sqliteInteger = autoIncrement && context.dialect === 'sqlite' && field.type === 'bigInt';
+    const entries = compact([
+        isKey ? 'primaryKey: true' : undefined,
+        autoIncrement ? 'autoIncrement: true' : undefined,
+        !isKey && !field.isNullable ? 'allowNull: false' : undefined,
+        field.isUnique && !isKey
+            ? field.uniqueName === undefined
+                ? 'unique: true'
+                : `unique: ${quote(field.uniqueName)}`
+            : undefined,
+        defaultValue === undefined ? undefined : `defaultValue: ${defaultValue}`,
+        columnEntry(plan, name, field.columnName),
+    ]);
+    const optional = field.isNullable ||
+        autoIncrement ||
+        defaultValue !== undefined ||
+        field.default?.kind === 'autoIncrement';
+    return {
+        name,
+        // SQLite only allows AUTOINCREMENT on INTEGER PRIMARY KEY, which already holds 64 bits.
+        type: sqliteInteger ? 'DataTypes.INTEGER' : spec.expression,
+        entries,
+        ts: sqliteInteger ? 'number' : spec.ts,
+        optional,
+        isReadonly: false,
+        implicit: false,
+    };
+}
+/** The columns Sequelize adds for `timestamps`: required date-times that it fills in itself. */
+function implicitTimestamp(name) {
+    return {
+        name,
+        type: 'DataTypes.DATE',
+        entries: ['allowNull: false'],
+        ts: 'Date',
+        optional: true,
+        isReadonly: true,
+        implicit: true,
+    };
+}
+/** Resolves the column a relation points at: an explicit `toField`, otherwise the single primary key. */
+function referencedKey(context, target, toField, depth = 0) {
+    if (depth > 5) {
+        return undefined;
+    }
+    const plan = planOf(context, target);
+    const explicit = toField === undefined
+        ? undefined
+        : target.fields.find((field) => field.name === toField || field.columnName === toField);
+    const column = explicit ?? target.fields.find((field) => field.isPrimaryKey);
+    if (column !== undefined) {
+        return { field: column, attr: plan.attrs.get(column.name) ?? column.name };
+    }
+    const primary = target.relations.find((relation) => relation.isPrimaryKey === true);
+    if (primary === undefined) {
+        return undefined;
+    }
+    const chained = findModel(context.schema, primary.targetModel);
+    const chainedKey = chained === undefined
+        ? undefined
+        : referencedKey(context, chained, primary.toField, depth + 1);
+    return chainedKey === undefined
+        ? undefined
+        : {
+            field: chainedKey.field,
+            attr: plan.keys.get(primary.name) ?? chainedKey.attr,
+        };
+}
+function keyAttribute(context, plan, relation, key) {
+    const model = plan.model;
+    const label = `${model.name}.${relation.name}`;
+    const name = plan.keys.get(relation.name) ?? relation.columnName;
+    const spec = typeSpecOf(context, label, {
+        ...key.field,
+        default: undefined,
+        isUnique: false,
+        isNullable: relation.isNullable,
+        arrayDepth: undefined,
+    }, true);
+    const isKey = relation.isPrimaryKey === true ||
+        (model.compositePrimaryKey?.includes(relation.name) ?? false);
+    const entries = compact([
+        isKey ? 'primaryKey: true' : undefined,
+        !isKey && !relation.isNullable ? 'allowNull: false' : undefined,
+        relation.kind === 'oneToOne' && !isKey ? 'unique: true' : undefined,
+        columnEntry(plan, name, relation.columnName),
+    ]);
+    return {
+        name,
+        type: spec.expression,
+        entries,
+        ts: spec.ts,
+        optional: relation.isNullable,
+        isReadonly: false,
+        implicit: false,
+    };
+}
+// ---------------------------------------------------------------------------
+// Indexes
+// ---------------------------------------------------------------------------
+function indexColumn(context, model, name) {
+    const relation = model.relations.find((candidate) => candidate.kind !== 'manyToMany' && candidate.name === name) ??
+        model.relations.find((candidate) => candidate.kind !== 'manyToMany' && candidate.columnName === name);
+    if (relation !== undefined) {
+        return relation.columnName;
+    }
+    const field = model.fields.find((candidate) => candidate.name === name) ??
+        model.fields.find((candidate) => candidate.columnName === name);
+    void context;
+    return field?.columnName;
+}
+function indexField(column, options) {
+    if (options === undefined) {
+        return quote(column);
+    }
+    const entries = compact([
+        `name: ${quote(column)}`,
+        options.sort === 'desc' ? `order: 'DESC'` : undefined,
+        options.length === undefined ? undefined : `length: ${options.length}`,
+        options.ops === undefined ? undefined : `operator: ${quote(options.ops)}`,
+    ]);
+    return entries.length === 1 ? quote(column) : `{ ${entries.join(', ')} }`;
+}
+function indexEntries(context, model, index) {
+    const label = `${model.name} index (${index.fields.join(', ')})`;
+    const fields = [];
+    for (const name of index.fields) {
+        const column = indexColumn(context, model, name);
+        if (column === undefined) {
+            context.warnings.push(`${label}: "${name}" is not a column of the model; the index was skipped.`);
+            return undefined;
+        }
+        fields.push(indexField(column, index.fieldOptions?.[name]));
+    }
+    const dialect = context.dialect;
+    let using;
+    if (index.method !== undefined) {
+        const method = INDEX_METHODS[index.method.toLowerCase()];
+        if (method === undefined) {
+            context.warnings.push(`${label}: the index method "${index.method}" is not known to Sequelize and was dropped.`);
+        }
+        else if (dialect === 'postgres' || dialect === 'mysql') {
+            using = method;
+        }
+        else {
+            context.warnings.push(`${label}: ${dialectName(dialect)} has no index methods; USING ${method} was dropped.`);
+        }
+    }
+    let fullText = false;
+    if (index.kind === 'fulltext') {
+        if (dialect === 'mysql') {
+            fullText = true;
+        }
+        else {
+            context.warnings.push(`${label}: full-text indexes are a MySQL feature in Sequelize; it was written as an ordinary index.`);
+        }
+    }
+    if (index.clustered !== undefined) {
+        context.warnings.push(`${label}: clustered and non-clustered options have no Sequelize equivalent and were dropped.`);
+    }
+    return compact([
+        index.name === undefined ? undefined : `name: ${quote(index.name)}`,
+        index.isUnique ? 'unique: true' : undefined,
+        fullText ? `type: 'FULLTEXT'` : undefined,
+        using === undefined ? undefined : `using: ${quote(using)}`,
+        `fields: [${fields.join(', ')}]`,
+    ]);
+}
+function renderModel(context, plan, associations) {
+    const model = plan.model;
+    const attributes = [];
+    const timestamps = plan.timestamps;
+    const timestampKinds = new Map();
+    if (timestamps.created !== undefined) {
+        timestampKinds.set(timestamps.created, 'created');
+    }
+    if (timestamps.updated !== undefined) {
+        timestampKinds.set(timestamps.updated, 'updated');
+    }
+    for (const field of model.fields) {
+        const kind = timestampKinds.get(field);
+        if (kind !== undefined && isImplicitTimestamp(plan, field, kind)) {
+            attributes.push(implicitTimestamp(plan.attrs.get(field.name) ?? field.name));
+            continue;
+        }
+        attributes.push(fieldAttribute(context, plan, field));
+    }
+    for (const relation of model.relations) {
+        renderRelation(context, plan, relation, attributes, associations);
+    }
+    const hasPrimaryKey = model.fields.some((field) => field.isPrimaryKey) ||
+        model.relations.some((relation) => relation.isPrimaryKey === true) ||
+        (model.compositePrimaryKey?.length ?? 0) > 0;
+    let removeId = false;
+    if (model.isView === true) {
+        context.warnings.push(`${model.name}: this is a database view; it was written as a model of the same name, but Sequelize cannot define a view, so sync() would create a table instead.`);
+    }
+    if (!hasPrimaryKey) {
+        const idAttribute = attributes.find((attribute) => attribute.name === 'id');
+        if (idAttribute === undefined) {
+            removeId = true;
+            context.warnings.push(`${model.name}: the model has no primary key; Sequelize would add an "id" column, so removeAttribute('id') was written. Most Sequelize features need a key.`);
+        }
+        else {
+            idAttribute.entries = [
+                'primaryKey: true',
+                ...idAttribute.entries.filter((entry) => entry !== 'allowNull: false'),
+            ];
+            context.warnings.push(`${model.name}: the model has no primary key, and Sequelize refuses a model with an "id" column that is not one; "id" was written with primaryKey: true.`);
+        }
+    }
+    const options = [`tableName: ${quote(model.tableName)}`];
+    if (model.schema !== undefined) {
+        if (context.dialect === 'sqlite') {
+            // Sequelize would name the SQLite table "schema.table" instead.
+            context.warnings.push(`${model.name}: SQLite has no database schemas; the schema "${model.schema}" was ignored.`);
+        }
+        else {
+            options.push(`schema: ${quote(model.schema)}`);
+        }
+    }
+    const enabled = timestamps.created !== undefined || timestamps.updated !== undefined;
+    options.push(`timestamps: ${enabled ? 'true' : 'false'}`);
+    if (enabled) {
+        const createdName = timestamps.created === undefined
+            ? undefined
+            : plan.attrs.get(timestamps.created.name);
+        const updatedName = timestamps.updated === undefined
+            ? undefined
+            : plan.attrs.get(timestamps.updated.name);
+        if (createdName === undefined) {
+            options.push('createdAt: false');
+        }
+        else if (createdName !== 'createdAt') {
+            options.push(`createdAt: ${quote(createdName)}`);
+        }
+        if (updatedName === undefined) {
+            options.push('updatedAt: false');
+        }
+        else if (updatedName !== 'updatedAt') {
+            options.push(`updatedAt: ${quote(updatedName)}`);
+        }
+    }
+    if (plan.underscored) {
+        options.push('underscored: true');
+    }
+    const indexLines = [];
+    for (const index of model.indexes) {
+        const entries = indexEntries(context, model, index);
+        if (entries !== undefined) {
+            indexLines.push(...objectLines('', entries, INDENT, ','));
+        }
+    }
+    return {
+        attributes,
+        options,
+        indexLines,
+        removeId,
+        usesLiteral: context.usesLiteral,
+    };
+}
+function actionOptions(relation) {
+    const entries = [
+        `onDelete: ${quote(ON_ACTIONS[relation.onDelete])}`,
+    ];
+    // ON UPDATE CASCADE is what Sequelize adds to every key; only another action is written.
+    if (relation.onUpdate !== undefined && relation.onUpdate !== 'cascade') {
+        entries.push(`onUpdate: ${quote(ON_ACTIONS[relation.onUpdate])}`);
+    }
+    return entries;
+}
+function addAssociation(associations, spec) {
+    const list = associations.byOwner.get(spec.owner) ?? [];
+    list.push(spec);
+    associations.byOwner.set(spec.owner, list);
+    associations.ordered.push(spec);
+}
+function renderRelation(context, plan, relation, attributes, associations) {
+    const model = plan.model;
+    const label = `${model.name}.${relation.name}`;
+    const target = findModel(context.schema, relation.targetModel);
+    if (target === undefined) {
+        context.warnings.push(`${label}: target model "${relation.targetModel}" does not exist in the schema; the relation was skipped.`);
+        return;
+    }
+    const targetPlan = planOf(context, target);
+    const alias = plan.aliases.get(relation.name) ?? relation.name;
+    const inverse = context.inverseAliases.get(label);
+    if (relation.kind === 'manyToMany') {
+        renderManyToMany(context, plan, targetPlan, relation, alias, inverse, associations);
+        return;
+    }
+    const key = referencedKey(context, target, relation.toField);
+    if (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 attribute = keyAttribute(context, plan, relation, key);
+    attributes.push(attribute);
+    const keyOption = `foreignKey: ${quote(attribute.name)}`;
+    const toKey = relation.toField === undefined ? undefined : key.attr;
+    addAssociation(associations, {
+        owner: plan.className,
+        method: 'belongsTo',
+        relation: label,
+        target: targetPlan.className,
+        alias,
+        options: compact([
+            `as: ${quote(alias)}`,
+            keyOption,
+            toKey === undefined ? undefined : `targetKey: ${quote(toKey)}`,
+            ...actionOptions(relation),
+        ]),
+    });
+    if (inverse !== undefined) {
+        addAssociation(associations, {
+            owner: targetPlan.className,
+            method: relation.kind === 'oneToOne' ? 'hasOne' : 'hasMany',
+            relation: label,
+            target: plan.className,
+            alias: inverse,
+            options: compact([
+                `as: ${quote(inverse)}`,
+                keyOption,
+                toKey === undefined ? undefined : `sourceKey: ${quote(toKey)}`,
+                ...actionOptions(relation),
+            ]),
+        });
+    }
+}
+function renderManyToMany(context, plan, targetPlan, relation, alias, inverse, associations) {
+    const model = plan.model;
+    const target = targetPlan.model;
+    const label = `${model.name}.${relation.name}`;
+    const hasSingleKey = (candidate) => candidate.fields.filter((field) => field.isPrimaryKey).length ===
+        1;
+    if (!hasSingleKey(model) || !hasSingleKey(target)) {
+        context.warnings.push(`${label}: a many-to-many relation needs a single-column primary key on both models; the relation was skipped.`);
+        return;
+    }
+    const isSelf = model.name === target.name;
+    const ownerColumn = `${isSelf ? 'from_' : ''}${toSnakeCase(model.name)}_id`;
+    const targetColumn = `${isSelf ? 'to_' : ''}${toSnakeCase(target.name)}_id`;
+    // The join table the other emitters derive; Sequelize creates it itself.
+    const table = quote(`${model.tableName}_${relation.name}`);
+    addAssociation(associations, {
+        owner: plan.className,
+        method: 'belongsToMany',
+        relation: label,
+        target: targetPlan.className,
+        alias,
+        options: [
+            `as: ${quote(alias)}`,
+            `through: ${table}`,
+            `foreignKey: ${quote(ownerColumn)}`,
+            `otherKey: ${quote(targetColumn)}`,
+            'timestamps: false',
+        ],
+    });
+    if (inverse !== undefined) {
+        addAssociation(associations, {
+            owner: targetPlan.className,
+            method: 'belongsToMany',
+            relation: label,
+            target: plan.className,
+            alias: inverse,
+            options: [
+                `as: ${quote(inverse)}`,
+                `through: ${table}`,
+                `foreignKey: ${quote(targetColumn)}`,
+                `otherKey: ${quote(ownerColumn)}`,
+                'timestamps: false',
+            ],
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Output: attribute and association text
+// ---------------------------------------------------------------------------
+function attributeLines(attribute, indent) {
+    const key = IDENTIFIER_PATTERN.test(attribute.name)
+        ? attribute.name
+        : quote(attribute.name);
+    if (attribute.entries.length === 0) {
+        return [`${indent}${key}: ${attribute.type},`];
+    }
+    return objectLines(`${key}: `, [`type: ${attribute.type}`, ...attribute.entries], indent, ',');
+}
+function associationLines(spec, targetExpression, indent) {
+    const head = `${spec.owner}.${spec.method}(${targetExpression}, `;
+    const inline = `${indent}${head}{ ${spec.options.join(', ')} });`;
+    if (inline.length <= MAX_LINE_WIDTH) {
+        return [inline];
+    }
+    return [
+        `${indent}${spec.owner}.${spec.method}(${targetExpression}, {`,
+        ...spec.options.map((entry) => `${indent}${INDENT}${entry},`),
+        `${indent}});`,
+    ];
+}
+function optionBlock(leading, rendered, indent) {
+    const lines = [];
+    const entries = [...leading, ...rendered.options];
+    const inline = `${indent}{ ${[...entries].join(', ')} }`;
+    if (rendered.indexLines.length === 0 && inline.length <= MAX_LINE_WIDTH) {
+        return [inline];
+    }
+    lines.push(`${indent}{`);
+    for (const entry of entries) {
+        lines.push(`${indent}${INDENT}${entry},`);
+    }
+    if (rendered.indexLines.length > 0) {
+        lines.push(`${indent}${INDENT}indexes: [`);
+        for (const line of rendered.indexLines) {
+            lines.push(`${indent}${INDENT}${line}`);
+        }
+        lines.push(`${indent}${INDENT}],`);
+    }
+    lines.push(`${indent}}`);
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Output: init style (TypeScript)
+// ---------------------------------------------------------------------------
+function creationType(attribute, nullable) {
+    const base = nullable ? `${attribute.ts} | null` : attribute.ts;
+    return attribute.optional ? `CreationOptional<${base}>` : base;
+}
+function writeInitFile(context, plan, rendered, associations) {
+    const own = associations.byOwner.get(plan.className) ?? [];
+    const nullableByName = new Set();
+    for (const field of plan.model.fields) {
+        if (field.isNullable) {
+            nullableByName.add(plan.attrs.get(field.name) ?? field.name);
+        }
+    }
+    for (const relation of plan.model.relations) {
+        const key = plan.keys.get(relation.name);
+        if (relation.isNullable && key !== undefined) {
+            nullableByName.add(key);
+        }
+    }
+    const needsCreationOptional = rendered.attributes.some((attribute) => attribute.optional);
+    const classLines = rendered.attributes.map((attribute) => `${INDENT}declare ${attribute.isReadonly ? 'readonly ' : ''}${attribute.name}: ${creationType(attribute, nullableByName.has(attribute.name))};`);
+    const importedTypes = new Set();
+    const associationLinesOut = [];
+    for (const spec of own) {
+        const many = spec.method === 'hasMany' || spec.method === 'belongsToMany';
+        if (spec.target !== plan.className) {
+            importedTypes.add(spec.target);
+        }
+        associationLinesOut.push(`${INDENT}declare ${spec.alias}?: NonAttribute<${spec.target}${many ? '[]' : ''}>;`);
+    }
+    const valueImports = ['DataTypes', 'Model'];
+    const typeImports = ['InferAttributes', 'InferCreationAttributes'];
+    if (rendered.usesLiteral) {
+        valueImports.push('Sequelize');
+    }
+    else {
+        typeImports.push('Sequelize');
+    }
+    if (needsCreationOptional) {
+        typeImports.push('CreationOptional');
+    }
+    if (associationLinesOut.length > 0) {
+        typeImports.push('NonAttribute');
+    }
+    typeImports.sort((first, second) => first.localeCompare(second));
+    const specifiers = [
+        ...valueImports,
+        ...typeImports.map((name) => `type ${name}`),
+    ];
+    const lines = [
+        'import {',
+        ...specifiers.map((specifier) => `${INDENT}${specifier},`),
+        `} from 'sequelize';`,
+    ];
+    const typeFiles = [...importedTypes].sort();
+    for (const name of typeFiles) {
+        lines.push(`import type { ${name} } from '${fileOf(context, name)}';`);
+    }
+    lines.push('', ...classHeader(plan), ...classLines);
+    if (associationLinesOut.length > 0) {
+        lines.push('', ...associationLinesOut);
+    }
+    lines.push('', `${INDENT}static initModel(sequelize: Sequelize): typeof ${plan.className} {`, `${INDENT}${INDENT}${plan.className}.init(`, `${INDENT}${INDENT}${INDENT}{`);
+    for (const attribute of rendered.attributes) {
+        lines.push(...attributeLines(attribute, INDENT.repeat(4)));
+    }
+    lines.push(`${INDENT}${INDENT}${INDENT}},`, ...optionBlock(['sequelize', `modelName: ${quote(plan.className)}`], rendered, INDENT.repeat(3)), `${INDENT}${INDENT});`);
+    if (rendered.removeId) {
+        lines.push(`${INDENT}${INDENT}${plan.className}.removeAttribute('id');`);
+    }
+    lines.push(`${INDENT}${INDENT}return ${plan.className};`, `${INDENT}}`, '}', '');
+    return lines.join('\n');
+}
+function classHeader(plan) {
+    const name = plan.className;
+    const inline = `export class ${name} extends Model<InferAttributes<${name}>, InferCreationAttributes<${name}>> {`;
+    if (inline.length <= MAX_LINE_WIDTH) {
+        return [inline];
+    }
+    return [
+        `export class ${name} extends Model<`,
+        `${INDENT}InferAttributes<${name}>,`,
+        `${INDENT}InferCreationAttributes<${name}>`,
+        '> {',
+    ];
+}
+/** Import path of another model's file, found by class name. */
+function fileOf(context, className) {
+    for (const plan of context.plans.values()) {
+        if (plan.className === className) {
+            return `./${plan.fileBase}.js`;
+        }
+    }
+    return `./${className}.js`;
+}
+function writeInitIndex(context, associations) {
+    const plans = context.schema.models.map((model) => planOf(context, model));
+    const lines = [`import type { Sequelize } from 'sequelize';`];
+    for (const plan of plans) {
+        lines.push(`import { ${plan.className} } from './${plan.fileBase}.js';`);
+    }
+    lines.push('', `export { ${plans.map((plan) => plan.className).join(', ')} };`, '', '/** Initializes every model on a Sequelize instance, then sets up the associations. */', 'export function initModels(sequelize: Sequelize) {');
+    for (const plan of plans) {
+        lines.push(`${INDENT}${plan.className}.initModel(sequelize);`);
+    }
+    // The relations keep the order of the schema: a many-to-many pair is read with its first call as the owner.
+    let previous;
+    for (const spec of associations.ordered) {
+        if (spec.relation !== previous) {
+            lines.push('');
+            previous = spec.relation;
+        }
+        lines.push(...associationLines(spec, spec.target, INDENT));
+    }
+    lines.push('', `${INDENT}return { ${plans.map((plan) => plan.className).join(', ')} };`, '}', '', 'export type Models = ReturnType<typeof initModels>;', '');
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Output: define style (sequelize-cli CommonJS)
+// ---------------------------------------------------------------------------
+function writeDefineFile(plan, rendered, associations) {
+    const own = associations.byOwner.get(plan.className) ?? [];
+    const lines = [`'use strict';`, ''];
+    if (rendered.usesLiteral) {
+        lines.push(`const { Sequelize } = require('sequelize');`, '');
+    }
+    lines.push('module.exports = (sequelize, DataTypes) => {', `${INDENT}const ${plan.className} = sequelize.define(`, `${INDENT}${INDENT}${quote(plan.className)},`, `${INDENT}${INDENT}{`);
+    for (const attribute of rendered.attributes) {
+        if (!attribute.implicit) {
+            lines.push(...attributeLines(attribute, INDENT.repeat(3)));
+        }
+    }
+    lines.push(`${INDENT}${INDENT}},`, ...optionBlock([], rendered, INDENT.repeat(2)), `${INDENT});`);
+    if (rendered.removeId) {
+        lines.push('', `${INDENT}${plan.className}.removeAttribute('id');`);
+    }
+    if (own.length > 0) {
+        lines.push('', `${INDENT}${plan.className}.associate = (models) => {`);
+        for (const spec of own) {
+            lines.push(...associationLines(spec, `models.${spec.target}`, INDENT.repeat(2)));
+        }
+        lines.push(`${INDENT}};`);
+    }
+    lines.push('', `${INDENT}return ${plan.className};`, '};', '');
+    return lines.join('\n');
+}
+function writeDefineIndex(context) {
+    const plans = context.schema.models.map((model) => planOf(context, model));
+    const lines = [
+        `'use strict';`,
+        '',
+        `const { DataTypes } = require('sequelize');`,
+        '',
+        '// Defines every model on a Sequelize instance, then runs the associate functions:',
+        "//   const { initModels } = require('./models');",
+        '//   const models = initModels(sequelize);',
+        'function initModels(sequelize) {',
+        `${INDENT}const models = {`,
+    ];
+    for (const plan of plans) {
+        lines.push(`${INDENT}${INDENT}${plan.className}: require('./${plan.fileBase}')(sequelize, DataTypes),`);
+    }
+    lines.push(`${INDENT}};`, `${INDENT}Object.values(models).forEach((model) => {`, `${INDENT}${INDENT}if (model.associate) {`, `${INDENT}${INDENT}${INDENT}model.associate(models);`, `${INDENT}${INDENT}}`, `${INDENT}});`, `${INDENT}return models;`, '}', '', 'module.exports = { initModels };', '');
+    return lines.join('\n');
+}
+//# sourceMappingURL=sequelize.js.map