ormbridge 0.14.0 → 0.15.0

package/dist/emitters/sequelize.js

@@ -4,14 +4,25 @@ import { underscore } from '../parsers/sequelizeInflection.js';
 import { prismaOnlyWarnings } from '../prismaOnlyConstructs.js';
 import { normalizeSchema } from '../transforms.js';
 import { COCKROACH_PREFIX, cockroachInvertible, cockroachSequentialWarning, isCockroach, } from './cockroach.js';
+import { writeV7Index, writeV7ModelFile, } from './sequelize7.js';
+import { compact, IDENTIFIER_PATTERN, INDENT, MAX_LINE_WIDTH, objectLines, quote, } from './sequelizeText.js';
 export const SEQUELIZE_STYLES = ['init', 'define'];
+export const SEQUELIZE_GENERATIONS = [
+    'v6',
+    'v7',
+];
+export const SEQUELIZE_OUTPUT_STYLES = [
+    ...SEQUELIZE_STYLES,
+    ...SEQUELIZE_GENERATIONS,
+];
 /** 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_$]*$/;
+/** True when a value is a Sequelize 6 layout or a generation (`v6`, `v7`). */
+export function isSequelizeOutputStyle(value) {
+    return SEQUELIZE_OUTPUT_STYLES.includes(value);
+}
 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([
@@ -32,6 +43,24 @@ const RESERVED_CLASS_NAMES = new Set([
     'Boolean',
     'Models',
 ]);
+/** Names the Sequelize 7 model files import as well, which a class cannot take there. */
+const V7_RESERVED_CLASS_NAMES = new Set([
+    'Attribute',
+    'AutoIncrement',
+    'BelongsTo',
+    'BelongsToMany',
+    'ColumnName',
+    'CreatedAt',
+    'Default',
+    'HasMany',
+    'HasOne',
+    'NotNull',
+    'PrimaryKey',
+    'Table',
+    'Unique',
+    'UpdatedAt',
+    'sql',
+]);
 /** Words an attribute cannot be called on a Sequelize instance without shadowing a member of `Model`. */
 const RESERVED_ATTRIBUTES = new Set([
     'constructor',
@@ -82,7 +111,9 @@ const RANGE_SUBTYPES = {
 // ---------------------------------------------------------------------------
 export function emitSequelize(schema, options) {
     const prepared = options.naming === 'normalize' ? normalizeSchema(schema) : schema;
-    const style = options.style ?? 'init';
+    const style = options.style === undefined || options.style === 'v6'
+        ? 'init'
+        : options.style;
     const context = {
         schema: prepared,
         options,
@@ -98,7 +129,10 @@ export function emitSequelize(schema, options) {
     if (options.provider === 'mongodb') {
         context.warnings.push('Provider "mongodb": Sequelize is relational (it has no MongoDB dialect; use Mongoose); PostgreSQL column types were written.');
     }
-    if (context.cockroach) {
+    if (context.cockroach && style === 'v7') {
+        context.warnings.push(`${COCKROACH_PREFIX} Sequelize 7 has no CockroachDB dialect or patch package, so the models use the PostgreSQL dialect (@sequelize/postgres) and may meet differences it does not handle; hstore, range types and multi-dimensional arrays (which CockroachDB lacks) are written as JSONB or TEXT.`);
+    }
+    else if (context.cockroach) {
         context.warnings.push(`${COCKROACH_PREFIX} the models use the "postgres" dialect through the sequelize-cockroachdb package (Sequelize 6): DataTypes.INTEGER creates a 64-bit INT8 column there, and hstore, range types and multi-dimensional arrays (which CockroachDB lacks) are written as JSONB or TEXT.`);
     }
     const files = {};
@@ -110,8 +144,9 @@ export function emitSequelize(schema, options) {
     const associations = {
         byOwner: new Map(),
         ordered: [],
+        v7: new Map(),
     };
-    const extension = style === 'init' ? 'ts' : 'js';
+    const extension = style === 'define' ? 'js' : 'ts';
     const rendered = new Map();
     for (const model of prepared.models) {
         context.usesLiteral = false;
@@ -126,12 +161,19 @@ export function emitSequelize(schema, options) {
         files[`${plan.fileBase}.${extension}`] =
             style === 'init'
                 ? writeInitFile(context, plan, result, associations)
-                : writeDefineFile(plan, result, associations);
+                : style === 'v7'
+                    ? writeV7ModelFile(v7ModelOf(plan, result, associations), (className) => fileOf(context, className))
+                    : writeDefineFile(plan, result, associations);
     }
     files[`index.${extension}`] =
         style === 'init'
             ? writeInitIndex(context, associations)
-            : writeDefineIndex(context);
+            : style === 'v7'
+                ? writeV7Index(context.schema.models.map((model) => {
+                    const plan = planOf(context, model);
+                    return { className: plan.className, fileBase: plan.fileBase };
+                }), v7DialectOf(context), v7Notes(context))
+                : writeDefineIndex(context);
     if (context.sequentialKeys.length > 0) {
         context.warnings.push(cockroachSequentialWarning(context.sequentialKeys, 'autoIncrement creates a SERIAL column, which CockroachDB fills with unique_rowid() (64-bit values above 2^53 that a JavaScript number cannot hold exactly; sequelize-cockroachdb returns them as strings, so those keys and the foreign keys that point at them are typed string)'));
     }
@@ -174,16 +216,6 @@ function dialectOf(provider) {
 // ---------------------------------------------------------------------------
 // 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;
@@ -204,24 +236,6 @@ function identifier(context, owner, raw) {
     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';
 }
@@ -295,15 +309,18 @@ function chooseUnderscored(context, model, attrs) {
 }
 function planModels(context) {
     const fileBases = new Set(['index']);
-    const classNames = new Set(RESERVED_CLASS_NAMES);
+    const reserved = context.style === 'v7'
+        ? new Set([...RESERVED_CLASS_NAMES, ...V7_RESERVED_CLASS_NAMES])
+        : RESERVED_CLASS_NAMES;
+    const classNames = new Set(reserved);
     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)) {
+        const className = uniqueName(reserved.has(rawClass) ? `${rawClass}Model` : rawClass, classNames);
+        if (reserved.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';
@@ -419,6 +436,10 @@ function typeSpecOf(context, label, field, keyLike) {
     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 };
 }
+/** True for SQLite under Sequelize 7, whose dialect has no BIGINT, DECIMAL or CHAR type. */
+function v7Sqlite(context) {
+    return context.style === 'v7' && context.dialect === 'sqlite';
+}
 function dialectName(dialect) {
     switch (dialect) {
         case 'mysql':
@@ -493,10 +514,16 @@ function scalarTypeSpec(context, label, field, keyLike) {
                     : 'number',
             };
         case 'bigInt':
-            return { expression: 'DataTypes.BIGINT', ts: 'string' };
+            return v7Sqlite(context)
+                ? { expression: 'DataTypes.INTEGER', ts: 'number' }
+                : { expression: 'DataTypes.BIGINT', ts: 'string' };
         case 'float':
             return { expression: 'DataTypes.DOUBLE', ts: 'number' };
         case 'decimal': {
+            if (v7Sqlite(context)) {
+                context.warnings.push(`${label}: the Sequelize 7 SQLite dialect has no DECIMAL type; the column was written as DOUBLE, which is not exact.`);
+                return { expression: 'DataTypes.DOUBLE', ts: 'number' };
+            }
             const precision = field.maxDigits;
             const scale = field.decimalPlaces;
             const args = precision === undefined
@@ -523,7 +550,9 @@ function scalarTypeSpec(context, label, field, keyLike) {
             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' };
+            return v7Sqlite(context)
+                ? { expression: 'DataTypes.INTEGER', ts: 'number' }
+                : { expression: 'DataTypes.BIGINT', ts: 'string' };
         case 'ipAddress':
             return dialect === 'postgres'
                 ? { expression: 'DataTypes.INET', ts: 'string' }
@@ -617,7 +646,7 @@ function defaultOf(context, label, field) {
         }
         case 'dbExpression':
             context.usesLiteral = true;
-            return `Sequelize.literal(${quote(defaultExpression(context, value.expression))})`;
+            return `${context.style === 'v7' ? 'sql' : '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;
@@ -751,9 +780,10 @@ function fieldAttribute(context, plan, field) {
     };
 }
 /** The columns Sequelize adds for `timestamps`: required date-times that it fills in itself. */
-function implicitTimestamp(name) {
+function implicitTimestamp(name, timestamp) {
     return {
         name,
+        timestamp,
         type: 'DataTypes.DATE',
         entries: ['allowNull: false'],
         ts: 'Date',
@@ -925,7 +955,7 @@ function renderModel(context, plan, associations) {
     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));
+            attributes.push(implicitTimestamp(plan.attrs.get(field.name) ?? field.name, kind));
             continue;
         }
         attributes.push(fieldAttribute(context, plan, field));
@@ -944,7 +974,7 @@ function renderModel(context, plan, associations) {
         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.`);
+            context.warnings.push(`${model.name}: the model has no primary key; Sequelize would add an "id" column, so ${context.style === 'v7' ? 'noPrimaryKey: true' : "removeAttribute('id')"} was written. Most Sequelize features need a key.`);
         }
         else {
             idAttribute.entries = [
@@ -1047,6 +1077,15 @@ function renderRelation(context, plan, relation, attributes, associations) {
     attributes.push(attribute);
     const keyOption = `foreignKey: ${quote(attribute.name)}`;
     const toKey = relation.toField === undefined ? undefined : key.attr;
+    if (context.style === 'v7') {
+        addRelationV7(associations, plan, targetPlan, relation, {
+            alias,
+            inverse,
+            key: attribute.name,
+            targetKey: toKey,
+        });
+        return;
+    }
     addAssociation(associations, {
         owner: plan.className,
         method: 'belongsTo',
@@ -1091,6 +1130,40 @@ function renderManyToMany(context, plan, targetPlan, relation, alias, inverse, a
     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}`);
+    if (context.style === 'v7') {
+        let otherSide = inverse;
+        if (otherSide === undefined && isSelf) {
+            // Sequelize 7 refuses a self-referencing many-to-many whose two sides do not have different names.
+            otherSide = uniqueName(`${alias}Inverse`, plan.used);
+            context.warnings.push(`${label}: Sequelize 7 needs a name for the other side of a self-referencing many-to-many relation; "${otherSide}" was added.`);
+        }
+        // The two halves of a self-referencing relation would give the join model's associations the same names.
+        const throughNames = isSelf && otherSide !== undefined
+            ? `throughAssociations: { fromSource: ${quote(uniqueName(`${alias}Links`, plan.used))}, toSource: ${quote(`${alias}Source`)}, fromTarget: ${quote(uniqueName(`${otherSide}Links`, plan.used))}, toTarget: ${quote(`${alias}Target`)} }`
+            : undefined;
+        addAssociationV7(associations, plan.className, {
+            decorator: 'BelongsToMany',
+            alias,
+            target: targetPlan.className,
+            many: true,
+            options: compact([
+                `through: { model: ${table}, timestamps: false }`,
+                `foreignKey: ${quote(ownerColumn)}`,
+                `otherKey: ${quote(targetColumn)}`,
+                otherSide === undefined ? undefined : `inverse: ${quote(otherSide)}`,
+                throughNames,
+            ]),
+        });
+        if (otherSide !== undefined) {
+            addAssociationV7(associations, targetPlan.className, {
+                alias: otherSide,
+                target: plan.className,
+                many: true,
+                options: [],
+            });
+        }
+        return;
+    }
     addAssociation(associations, {
         owner: plan.className,
         method: 'belongsToMany',
@@ -1349,4 +1422,156 @@ function writeDefineIndex(context) {
     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');
 }
+// ---------------------------------------------------------------------------
+// Output: Sequelize 7 style (decorators)
+// ---------------------------------------------------------------------------
+function addAssociationV7(associations, owner, association) {
+    const list = associations.v7.get(owner) ?? [];
+    list.push(association);
+    associations.v7.set(owner, list);
+}
+/**
+ * Declares a relation once. The model that holds the key gets `@BelongsTo`, whose `inverse` option defines the
+ * other side as well; that side is only a typed property. A self reference is declared from the `@HasMany` /
+ * `@HasOne` side, because Sequelize 7 cannot build the inverse of a self-referencing `@BelongsTo`.
+ */
+function addRelationV7(associations, plan, targetPlan, relation, names) {
+    const entries = compact([
+        `onDelete: ${quote(ON_ACTIONS[relation.onDelete])}`,
+        // ON UPDATE CASCADE is what Sequelize adds to every key; only another action is written.
+        relation.onUpdate !== undefined && relation.onUpdate !== 'cascade'
+            ? `onUpdate: ${quote(ON_ACTIONS[relation.onUpdate])}`
+            : undefined,
+    ]);
+    const foreignKey = `foreignKey: { name: ${quote(names.key)}, ${entries.join(', ')} }`;
+    const isOne = relation.kind === 'oneToOne';
+    const { alias, inverse, targetKey } = names;
+    if (inverse === undefined) {
+        addAssociationV7(associations, plan.className, {
+            decorator: 'BelongsTo',
+            alias,
+            target: targetPlan.className,
+            many: false,
+            options: compact([
+                foreignKey,
+                targetKey === undefined ? undefined : `targetKey: ${quote(targetKey)}`,
+            ]),
+        });
+    }
+    else if (plan.className !== targetPlan.className) {
+        addAssociationV7(associations, plan.className, {
+            decorator: 'BelongsTo',
+            alias,
+            target: targetPlan.className,
+            many: false,
+            options: compact([
+                foreignKey,
+                targetKey === undefined ? undefined : `targetKey: ${quote(targetKey)}`,
+                `inverse: { type: ${quote(isOne ? 'hasOne' : 'hasMany')}, as: ${quote(inverse)} }`,
+            ]),
+        });
+        addAssociationV7(associations, targetPlan.className, {
+            alias: inverse,
+            target: plan.className,
+            many: !isOne,
+            options: [],
+        });
+    }
+    else {
+        addAssociationV7(associations, plan.className, {
+            decorator: isOne ? 'HasOne' : 'HasMany',
+            alias: inverse,
+            target: plan.className,
+            many: !isOne,
+            options: compact([
+                foreignKey,
+                targetKey === undefined ? undefined : `sourceKey: ${quote(targetKey)}`,
+                `inverse: ${quote(alias)}`,
+            ]),
+        });
+        addAssociationV7(associations, plan.className, {
+            alias,
+            target: plan.className,
+            many: false,
+            options: [],
+        });
+    }
+}
+/** What the Sequelize 7 text writer needs to know about one model. */
+function v7ModelOf(plan, rendered, associations) {
+    const nullable = new Set();
+    for (const field of plan.model.fields) {
+        if (field.isNullable) {
+            nullable.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) {
+            nullable.add(key);
+        }
+    }
+    const attributes = rendered.attributes.map((attribute) => ({
+        name: attribute.name,
+        type: attribute.type,
+        entries: attribute.entries,
+        ts: attribute.ts,
+        nullable: nullable.has(attribute.name),
+        optional: attribute.optional,
+        isReadonly: attribute.isReadonly,
+        ...(attribute.timestamp === undefined
+            ? {}
+            : { timestamp: attribute.timestamp }),
+    }));
+    // `@CreatedAt` / `@UpdatedAt` name the columns that Sequelize adds, so the options that rename them are redundant.
+    const created = attributes.some((attribute) => attribute.timestamp === 'created');
+    const updated = attributes.some((attribute) => attribute.timestamp === 'updated');
+    return {
+        className: plan.className,
+        attributes,
+        tableOptions: rendered.options.filter((entry) => !(created && entry.startsWith("createdAt: '")) &&
+            !(updated && entry.startsWith("updatedAt: '"))),
+        indexLines: rendered.indexLines,
+        associations: associations.v7.get(plan.className) ?? [],
+        noPrimaryKey: rendered.removeId,
+        usesSql: rendered.usesLiteral,
+    };
+}
+/** The Sequelize 7 dialect package and class for the provider, with the connection options of the example. */
+function v7DialectOf(context) {
+    switch (context.dialect) {
+        case 'mysql':
+            return {
+                package: '@sequelize/mysql',
+                dialect: 'MySqlDialect',
+                connection: ['url: process.env.DATABASE_URL'],
+            };
+        case 'sqlite':
+            return {
+                package: '@sequelize/sqlite3',
+                dialect: 'SqliteDialect',
+                connection: ["storage: 'database.sqlite'"],
+            };
+        case 'mssql':
+            return {
+                package: '@sequelize/mssql',
+                dialect: 'MsSqlDialect',
+                connection: ["server: 'localhost'", "database: 'app'"],
+            };
+        default:
+            return {
+                package: '@sequelize/postgres',
+                dialect: 'PostgresDialect',
+                connection: ['url: process.env.DATABASE_URL'],
+            };
+    }
+}
+/** Remarks for the comment of the `index` file. */
+function v7Notes(context) {
+    return context.cockroach
+        ? [
+            'CockroachDB: Sequelize 7 has no CockroachDB dialect; the PostgreSQL dialect above talks to it.',
+        ]
+        : [];
+}
 //# sourceMappingURL=sequelize.js.map