@mikro-orm/sql 7.0.13-dev.7 → 7.0.13-dev.8

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -90,18 +90,27 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
     }
     normalizeColumnType(type, options) {
         const simpleType = this.extractSimpleType(type);
-        if (['int', 'int4', 'integer'].includes(simpleType)) {
+        if (['int', 'int4', 'integer', 'serial'].includes(simpleType)) {
             return this.getIntegerTypeDeclarationSQL({});
         }
-        if (['bigint', 'int8'].includes(simpleType)) {
+        if (['bigint', 'int8', 'bigserial'].includes(simpleType)) {
             return this.getBigIntTypeDeclarationSQL({});
         }
-        if (['smallint', 'int2'].includes(simpleType)) {
+        if (['smallint', 'int2', 'smallserial'].includes(simpleType)) {
             return this.getSmallIntTypeDeclarationSQL({});
         }
         if (['boolean', 'bool'].includes(simpleType)) {
             return this.getBooleanTypeDeclarationSQL();
         }
+        if (['double', 'double precision', 'float8'].includes(simpleType)) {
+            return this.getDoubleDeclarationSQL();
+        }
+        if (['real', 'float4'].includes(simpleType)) {
+            return this.getFloatDeclarationSQL();
+        }
+        if (['timestamptz', 'timestamp with time zone'].includes(simpleType)) {
+            return this.getDateTimeTypeDeclarationSQL(options);
+        }
         if (['varchar', 'character varying'].includes(simpleType)) {
             return this.getVarcharTypeDeclarationSQL(options);
         }

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -15,6 +15,7 @@ export declare class SqlitePlatform extends AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column: {
         length: number;
     }): string;
+    getDefaultVersionLength(): number;
     getBeginTransactionSQL(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;

package/dialects/sqlite/SqlitePlatform.js

@@ -24,6 +24,10 @@ export class SqlitePlatform extends AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column) {
         return 'datetime';
     }
+    // sqlite's datetime DDL drops precision and the current-ts expression hardcodes ms scaling
+    getDefaultVersionLength() {
+        return 0;
+    }
     getBeginTransactionSQL(options) {
         return ['begin'];
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -44,7 +44,8 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      * We need to add them back so they match what we generate in DDL.
      */
     private wrapExpressionDefault;
-    private getEnumDefinitions;
+    /** Extract enum values from `IN (…)` CHECKs only — a `!= 'x'` check would otherwise be misread as a one-item enum. */
+    private extractEnumValuesFromChecks;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string, ctx?: Transaction): Promise<string[]>;
     private getIndexes;
     private getChecks;

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -100,7 +100,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             const checks = await this.getChecks(connection, table.name, table.schema, ctx);
             const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema, ctx);
             const fks = await this.getForeignKeys(connection, table.name, table.schema, ctx);
-            const enums = await this.getEnumDefinitions(connection, table.name, table.schema, ctx);
+            const enums = this.extractEnumValuesFromChecks(checks);
             table.init(cols, indexes, checks, pks, fks, enums);
         }
     }
@@ -321,23 +321,23 @@ export class SqliteSchemaHelper extends SchemaHelper {
         // everything else is an expression that had its outer parens stripped
         return `(${value})`;
     }
-    async getEnumDefinitions(connection, tableName, schemaName, ctx) {
-        const prefix = this.getSchemaPrefix(schemaName);
-        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
-        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get', ctx);
-        const checkConstraints = [...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? [])];
-        return checkConstraints.reduce((o, item) => {
-            // check constraints are defined as (note that last closing paren is missing):
-            // `type` text check (`type` in ('local', 'global')
-            const match = /[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i.exec(item);
-            /* v8 ignore next */
-            if (match) {
-                o[match[1]] = match[2]
-                    .split(/,(?=\s*'(?:[^']|'')*'(?:\s*\)|$))/)
-                    .map((item) => /^\(?'((?:[^']|'')*)'/.exec(item.trim())[1].replace(/''/g, "'"));
+    /** Extract enum values from `IN (…)` CHECKs only — a `!= 'x'` check would otherwise be misread as a one-item enum. */
+    extractEnumValuesFromChecks(checks) {
+        const result = {};
+        for (const check of checks) {
+            if (!check.columnName || typeof check.expression !== 'string') {
+                continue;
             }
-            return o;
-        }, {});
+            const inClause = /\bin\s*\(([^)]*)\)/i.exec(check.expression);
+            if (!inClause) {
+                continue;
+            }
+            const items = [...inClause[1].matchAll(/'((?:[^']|'')*)'/g)].map(m => m[1].replace(/''/g, "'"));
+            if (items.length > 0) {
+                result[check.columnName] = items;
+            }
+        }
+        return result;
     }
     async getPrimaryKeys(connection, indexes, tableName, schemaName, ctx) {
         const prefix = this.getSchemaPrefix(schemaName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.13-dev.7",
+  "version": "7.0.13-dev.8",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.12"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.13-dev.7"
+    "@mikro-orm/core": "7.0.13-dev.8"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/DatabaseSchema.js

@@ -323,12 +323,16 @@ export class DatabaseSchema {
             (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner));
     }
     toJSON() {
+        // locale-independent comparison so the snapshot is stable across machines
+        const byString = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+        const tableKey = (t) => `${t.schema ?? ''}.${t.name}`;
+        const byTable = (a, b) => byString(tableKey(a), tableKey(b));
         return {
             name: this.name,
-            namespaces: [...this.#namespaces],
-            tables: this.#tables,
-            views: this.#views,
-            nativeEnums: this.#nativeEnums,
+            namespaces: [...this.#namespaces].sort(),
+            tables: [...this.#tables].sort(byTable),
+            views: [...this.#views].sort(byTable),
+            nativeEnums: Object.fromEntries(Object.entries(this.#nativeEnums).sort(([a], [b]) => byString(a, b))),
         };
     }
     prune(schema, wildcardSchemaTables) {

package/schema/DatabaseTable.js

@@ -51,6 +51,7 @@ export class DatabaseTable {
         this.#indexes = indexes;
         this.#checks = checks;
         this.#foreignKeys = fks;
+        const helper = this.#platform.getSchemaHelper();
         this.#columns = cols.reduce((o, v) => {
             const index = indexes.filter(i => i.columnNames[0] === v.name);
             v.primary = v.primary || pks.includes(v.name);
@@ -59,6 +60,11 @@ export class DatabaseTable {
             v.mappedType = this.#platform.getMappedType(type);
             v.default = v.default?.toString().startsWith('nextval(') ? null : v.default;
             v.enumItems ??= enums[v.name] || [];
+            // recover length from the declared type so introspection matches `addColumnFromProperty`;
+            // scoped to types with `getDefaultLength` to skip mysql's `tinyint(1)` boolean width
+            if (v.length == null && v.type && helper && typeof v.mappedType.getDefaultLength !== 'undefined') {
+                v.length = helper.inferLengthFromColumnType(v.type);
+            }
             o[v.name] = v;
             return o;
         }, {});
@@ -68,7 +74,9 @@ export class DatabaseTable {
     }
     addColumnFromProperty(prop, meta, config) {
         prop.fieldNames?.forEach((field, idx) => {
-            const type = prop.enum ? 'enum' : prop.columnTypes[idx];
+            // numeric enums fall through to the underlying numeric type — no platform emits a CHECK we could parse back
+            const isStringEnum = !!prop.nativeEnumName || !!prop.items?.every(item => typeof item === 'string');
+            const type = prop.enum && isStringEnum ? 'enum' : prop.columnTypes[idx];
             const mappedType = this.#platform.getMappedType(type);
             if (mappedType instanceof DecimalType) {
                 const match = /\w+\((\d+), ?(\d+)\)/.exec(prop.columnTypes[idx]);
@@ -887,51 +895,135 @@ export class DatabaseTable {
     }
     toJSON() {
         const columns = this.#columns;
-        const columnsMapped = Utils.keys(columns).reduce((o, col) => {
+        // locale-independent comparison so the snapshot is stable across machines
+        const byString = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+        const sortedColumnKeys = Utils.keys(columns).sort(byString);
+        // mirror `DatabaseTable.init()`: derive `primary`/`unique` from index membership
+        // so metadata (which keeps `primary: false` on composite PK columns) and introspection agree
+        const primaryColumns = new Set();
+        const uniqueColumns = new Set();
+        for (const idx of this.#indexes) {
+            if (idx.primary) {
+                idx.columnNames.forEach(c => primaryColumns.add(c));
+            }
+            if (idx.unique && !idx.primary && idx.columnNames.length > 0) {
+                uniqueColumns.add(idx.columnNames[0]);
+            }
+        }
+        // integer/float widths live in the type name (`int2`/`int4`/`float8`) — drop redundant precision/scale
+        const isFixedPrecisionFamily = (mappedType) => mappedType instanceof t.integer ||
+            mappedType instanceof t.smallint ||
+            mappedType instanceof t.tinyint ||
+            mappedType instanceof t.mediumint ||
+            mappedType instanceof t.bigint ||
+            mappedType instanceof t.float ||
+            mappedType instanceof t.double;
+        const supportsUnsigned = this.#platform.supportsUnsigned();
+        const columnsMapped = sortedColumnKeys.reduce((o, col) => {
             const c = columns[col];
+            // omit `autoincrement` from options so `serial` (metadata) and `int4` (introspection) collapse the same
+            const rawType = c.type?.toLowerCase();
+            const normOptions = { length: c.length, precision: c.precision, scale: c.scale };
+            const type = this.#platform.normalizeColumnType(c.type ?? '', normOptions)?.toLowerCase() || rawType;
+            const fixedPrecision = isFixedPrecisionFamily(c.mappedType);
             const normalized = {
                 name: c.name,
-                type: c.type,
-                unsigned: !!c.unsigned,
+                type,
+                unsigned: supportsUnsigned && !!c.unsigned,
                 autoincrement: !!c.autoincrement,
-                primary: !!c.primary,
+                primary: primaryColumns.has(c.name) || !!c.primary,
                 nullable: !!c.nullable,
-                unique: !!c.unique,
-                length: c.length ?? null,
-                precision: c.precision ?? null,
-                scale: c.scale ?? null,
+                unique: uniqueColumns.has(c.name) || !!c.unique,
+                length: c.length || null,
+                precision: fixedPrecision ? null : (c.precision ?? null),
+                scale: fixedPrecision ? null : (c.scale ?? null),
                 default: c.default ?? null,
                 comment: c.comment ?? null,
                 enumItems: c.enumItems ?? [],
                 mappedType: Utils.keys(t).find(k => t[k] === c.mappedType.constructor),
             };
-            if (c.generated) {
-                normalized.generated = c.generated;
-            }
-            if (c.nativeEnumName) {
-                normalized.nativeEnumName = c.nativeEnumName;
-            }
-            if (c.extra) {
-                normalized.extra = c.extra;
-            }
-            if (c.ignoreSchemaChanges) {
-                normalized.ignoreSchemaChanges = c.ignoreSchemaChanges;
-            }
-            if (c.defaultConstraint) {
-                normalized.defaultConstraint = c.defaultConstraint;
+            for (const field of [
+                'generated',
+                'nativeEnumName',
+                'extra',
+                'ignoreSchemaChanges',
+                'defaultConstraint',
+            ]) {
+                if (c[field]) {
+                    normalized[field] = c[field];
+                }
             }
             o[col] = normalized;
             return o;
         }, {});
+        const normalizeIndex = (idx) => {
+            const out = {
+                columnNames: idx.columnNames,
+                composite: !!idx.composite,
+                // PK indexes are always backed by a constraint — force it so postgres introspection matches
+                constraint: !!idx.constraint || !!idx.primary,
+                keyName: idx.keyName,
+                primary: !!idx.primary,
+                unique: !!idx.unique,
+            };
+            const optional = [
+                'expression',
+                'type',
+                'deferMode',
+                'columns',
+                'include',
+                'fillFactor',
+                'invisible',
+                'disabled',
+                'clustered',
+            ];
+            for (const field of optional) {
+                if (idx[field] != null && idx[field] !== false) {
+                    out[field] = idx[field];
+                }
+            }
+            return out;
+        };
+        const normalizeFk = (fk) => {
+            const isNoAction = (rule) => !rule || rule.toLowerCase() === 'no action';
+            // JSON.stringify drops undefined properties — let them through instead of guarding
+            return {
+                columnNames: fk.columnNames,
+                constraintName: fk.constraintName,
+                localTableName: fk.localTableName,
+                referencedColumnNames: fk.referencedColumnNames,
+                referencedTableName: fk.referencedTableName,
+                updateRule: isNoAction(fk.updateRule) ? undefined : fk.updateRule,
+                deleteRule: isNoAction(fk.deleteRule) ? undefined : fk.deleteRule,
+                deferMode: fk.deferMode,
+            };
+        };
+        const normalizeCheck = (check) => {
+            const out = { name: check.name };
+            if (typeof check.expression === 'string') {
+                out.expression = check.expression;
+            }
+            for (const field of ['definition', 'columnName']) {
+                if (check[field]) {
+                    out[field] = check[field];
+                }
+            }
+            return out;
+        };
+        const sortedIndexes = [...this.#indexes].sort((a, b) => byString(a.keyName, b.keyName)).map(normalizeIndex);
+        const sortedChecks = [...this.#checks].sort((a, b) => byString(a.name, b.name)).map(normalizeCheck);
+        const sortedForeignKeys = Object.fromEntries(Object.entries(this.#foreignKeys)
+            .sort(([a], [b]) => byString(a, b))
+            .map(([k, v]) => [k, normalizeFk(v)]));
         return {
             name: this.name,
             schema: this.schema,
             columns: columnsMapped,
-            indexes: this.#indexes,
-            checks: this.#checks,
-            foreignKeys: this.#foreignKeys,
-            nativeEnums: this.nativeEnums,
-            comment: this.comment,
+            indexes: sortedIndexes,
+            checks: sortedChecks,
+            foreignKeys: sortedForeignKeys,
+            // emit `comment` even when unset so introspection (which always reads it) matches metadata
+            comment: this.comment ?? null,
         };
     }
 }

package/schema/SchemaHelper.js

@@ -42,7 +42,7 @@ export class SchemaHelper {
     }
     inferLengthFromColumnType(type) {
         const match = /^\w+\s*(?:\(\s*(\d+)\s*\)|$)/.exec(type);
-        if (!match) {
+        if (match?.[1] == null) {
             return;
         }
         return +match[1];