@mikro-orm/sql 7.1.2-dev.9 → 7.1.3-dev.0

package/AbstractSqlDriver.js

@@ -510,8 +510,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         else if (prop.fieldNames.length > 1) {
             // composite keys
             const fk = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
+            // `mapFlatCompositePrimaryKey` collapses to a scalar when the target PK is a single prop
+            // (e.g. a relation referencing a composite unique key on a single-PK target).
             const pk = Utils.mapFlatCompositePrimaryKey(fk, prop);
-            relationPojo[prop.name] = pk.every(val => val != null) ? pk : null;
+            const valid = Array.isArray(pk) ? pk.every(val => val != null) : pk != null;
+            relationPojo[prop.name] = valid ? pk : null;
         }
         else if (prop.runtimeType === 'Date') {
             const alias = `${relationAlias}__${prop.fieldNames[0]}`;

package/dialects/postgresql/BasePostgreSqlPlatform.js

@@ -126,6 +126,11 @@ export class BasePostgreSqlPlatform extends AbstractSqlPlatform {
         if (['interval'].includes(simpleType)) {
             return this.getIntervalTypeDeclarationSQL(options);
         }
+        // postgis reports the typmod without spaces (`geometry(point,4326)`) — collapse any
+        // user-supplied spacing so the metadata and introspection forms compare equal
+        if (['geometry', 'geography'].includes(simpleType)) {
+            return type.toLowerCase().replace(/\s+/g, '');
+        }
         // TimeType.getColumnType drops the timezone qualifier, so detect tz aliases from the original column type.
         const originalType = options.columnTypes?.[0]?.toLowerCase() ?? type;
         if (/^timetz\b/.test(originalType) || /^time\s+with\s+time\s+zone\b/.test(originalType)) {

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -370,6 +370,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       is_nullable,
       udt_name,
       udt_schema,
+      pg_catalog.format_type(pga.atttypid, pga.atttypmod) format_type,
       coalesce(datetime_precision, character_maximum_length) length,
       atttypmod custom_length,
       numeric_precision,
@@ -404,6 +405,11 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (type === 'bpchar') {
                 type = 'char';
             }
+            // postgis stores the geometry/geography typmod (`geometry(point,4326)`) in atttypmod, which
+            // information_schema does not expose — recover the full type via format_type so it round-trips
+            if ((col.udt_name === 'geometry' || col.udt_name === 'geography') && col.format_type) {
+                type = col.format_type;
+            }
             if (type === 'vector' && col.length == null && col.custom_length != null && col.custom_length !== -1) {
                 col.length = col.custom_length;
             }

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -11,6 +11,7 @@ export declare class SqlitePlatform extends AbstractSqlPlatform {
     usesDefaultKeyword(): boolean;
     usesReturningStatement(): boolean;
     usesEnumCheckConstraints(): boolean;
+    supportsComments(): boolean;
     getCurrentTimestampSQL(length: number): string;
     getDateTimeTypeDeclarationSQL(column: {
         length: number;

package/dialects/sqlite/SqlitePlatform.js

@@ -18,6 +18,10 @@ export class SqlitePlatform extends AbstractSqlPlatform {
     usesEnumCheckConstraints() {
         return true;
     }
+    // sqlite has no table/column comments, so they cannot round-trip through introspection
+    supportsComments() {
+        return false;
+    }
     getCurrentTimestampSQL(length) {
         return `(strftime('%s', 'now') * 1000)`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.2-dev.9",
+  "version": "7.1.3-dev.0",
   "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",
@@ -50,10 +50,10 @@
     "kysely": "0.29.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.1.1"
+    "@mikro-orm/core": "^7.1.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.2-dev.9"
+    "@mikro-orm/core": "7.1.3-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/DatabaseSchema.js

@@ -233,7 +233,9 @@ export class DatabaseSchema {
                     ? platform.formatQuery(check.expression.sql, check.expression.params)
                     : check.expression;
                 table.addCheck({
-                    name: check.name,
+                    // the engine truncates identifiers past its limit (postgres 63 bytes) on storage, so
+                    // mirror that here — otherwise the introspected (truncated) name never matches metadata
+                    name: check.name.substring(0, platform.getMaxIdentifierLength()),
                     expression,
                     definition: `check (${expression})`,
                     columnName,

package/schema/DatabaseTable.js

@@ -975,6 +975,7 @@ export class DatabaseTable {
             mappedType instanceof t.float ||
             mappedType instanceof t.double;
         const supportsUnsigned = this.#platform.supportsUnsigned();
+        const supportsComments = this.#platform.supportsComments();
         const columnsMapped = sortedColumnKeys.reduce((o, col) => {
             const c = columns[col];
             // omit `autoincrement` from options so `serial` (metadata) and `int4` (introspection) collapse the same
@@ -982,6 +983,15 @@ export class DatabaseTable {
             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);
+            // only emit `length` for types that actually use one — text/enum/json/etc. don't, but mysql
+            // information_schema still reports `character_maximum_length` for them (65535 for text, etc.)
+            const hasMeaningfulLength = typeof c.mappedType.getDefaultLength !== 'undefined';
+            // mysql stores decimal defaults padded to scale (`0` → `0.00`); collapse to canonical numeric form
+            // so the metadata-side (`0`) and introspection-side (`0.00`) snapshots agree
+            let defaultValue = c.default ?? null;
+            if (defaultValue != null && c.mappedType instanceof DecimalType && Number.isFinite(+defaultValue)) {
+                defaultValue = this.#platform.formatDecimal(defaultValue, c.scale).toString();
+            }
             const normalized = {
                 name: c.name,
                 type,
@@ -990,26 +1000,26 @@ export class DatabaseTable {
                 primary: primaryColumns.has(c.name) || !!c.primary,
                 nullable: !!c.nullable,
                 unique: uniqueColumns.has(c.name) || !!c.unique,
-                length: c.length || null,
+                length: hasMeaningfulLength ? c.length || null : null,
                 precision: fixedPrecision ? null : (c.precision ?? null),
                 scale: fixedPrecision ? null : (c.scale ?? null),
-                default: c.default ?? null,
-                comment: c.comment ?? null,
+                default: defaultValue,
+                comment: supportsComments ? c.comment || null : null,
                 collation: c.collation ?? null,
                 enumItems: c.enumItems ?? [],
                 mappedType: Utils.keys(t).find(k => t[k] === c.mappedType.constructor),
             };
-            for (const field of [
-                'generated',
-                'nativeEnumName',
-                'extra',
-                'ignoreSchemaChanges',
-                'defaultConstraint',
-            ]) {
+            for (const field of ['generated', 'nativeEnumName', 'ignoreSchemaChanges', 'defaultConstraint']) {
                 if (c[field]) {
                     normalized[field] = c[field];
                 }
             }
+            // `extra` casing varies between metadata (user-supplied, typically uppercase like
+            // `ON UPDATE CURRENT_TIMESTAMP`) and mysql introspection (returns it lowercased) — the
+            // comparator already lowercases both sides when diffing, mirror that in the snapshot
+            if (c.extra) {
+                normalized.extra = c.extra.toLowerCase();
+            }
             o[col] = normalized;
             return o;
         }, {});
@@ -1082,8 +1092,10 @@ export class DatabaseTable {
             checks: sortedChecks,
             triggers: sortedTriggers,
             foreignKeys: sortedForeignKeys,
-            // emit `comment` even when unset so introspection (which always reads it) matches metadata
-            comment: this.comment ?? null,
+            // emit `comment` even when unset so introspection (which always reads it) matches metadata;
+            // collapse mysql's `""` for unset comments to `null` so both sources agree. drop entirely on
+            // platforms that can't read comments back (sqlite), where keeping it would flip the snapshot
+            comment: supportsComments ? this.comment || null : null,
         };
     }
 }

package/schema/SchemaComparator.js

@@ -1,4 +1,4 @@
-import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
+import { ArrayType, BooleanType, DateTimeType, DecimalType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 import { diffPartitioning } from './partitioning.js';
 /**
@@ -339,7 +339,7 @@ export class SchemaComparator {
             fromTable,
             toTable,
         };
-        if (this.diffComment(fromTable.comment, toTable.comment)) {
+        if (this.#platform.supportsComments() && this.diffComment(fromTable.comment, toTable.comment)) {
             tableDifferences.changedComment = toTable.comment;
             this.log(`table comment changed for ${tableDifferences.name}`, {
                 fromTableComment: fromTable.comment,
@@ -713,7 +713,7 @@ export class SchemaComparator {
             log(`'default' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('default');
         }
-        if (this.diffComment(fromColumn.comment, toColumn.comment)) {
+        if (this.#platform.supportsComments() && this.diffComment(fromColumn.comment, toColumn.comment)) {
             log(`'comment' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('comment');
         }
@@ -996,6 +996,11 @@ export class SchemaComparator {
             const defaultValueTo = to.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');
             return defaultValueFrom === defaultValueTo;
         }
+        // mysql stores decimal defaults padded to scale (`0` → `0.00`); compare numerically so the
+        // entity-side raw literal and the introspected padded form don't churn the no-op migration
+        if (to.mappedType instanceof DecimalType && Number.isFinite(+from.default) && Number.isFinite(+to.default)) {
+            return (this.#platform.formatDecimal(from.default, to.scale) === this.#platform.formatDecimal(to.default, to.scale));
+        }
         if (from.default && to.default) {
             return from.default.toString().toLowerCase() === to.default.toString().toLowerCase();
         }