@mikro-orm/sql 7.2.5-dev.5 → 7.2.5-dev.7

package/AbstractSqlDriver.js

@@ -2087,6 +2087,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         const aliased = this.platform.quoteIdentifier(`${tableAlias}__${prop.fieldNames[0]}`);
         const sourceAlias = qb.helper.getTPTAliasForProperty(prop.name, tableAlias);
+        if (prop.formula) {
+            const quotedAlias = this.platform.quoteIdentifier(tableAlias).toString();
+            const table = this.createFormulaTable(quotedAlias, meta, schema);
+            const columns = meta.createColumnMappingObject(tableAlias);
+            return [raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`)];
+        }
         if (prop.customTypes?.some(type => !!type?.convertToJSValueSQL)) {
             return prop.fieldNames.map((col, idx) => {
                 if (!prop.customTypes[idx]?.convertToJSValueSQL) {
@@ -2101,12 +2107,6 @@ export class AbstractSqlDriver extends DatabaseDriver {
             const prefixed = this.platform.quoteIdentifier(`${sourceAlias}.${prop.fieldNames[0]}`);
             return [raw(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
         }
-        if (prop.formula) {
-            const quotedAlias = this.platform.quoteIdentifier(tableAlias).toString();
-            const table = this.createFormulaTable(quotedAlias, meta, schema);
-            const columns = meta.createColumnMappingObject(tableAlias);
-            return [raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`)];
-        }
         return prop.fieldNames.map(fieldName => {
             return raw('?? as ??', [`${sourceAlias}.${fieldName}`, `${tableAlias}__${fieldName}`]);
         });
@@ -2527,7 +2527,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     const table = this.createFormulaTable(quotedAlias.toString(), meta, effectiveSchema);
                     ret.push(raw(`${this.evaluateFormula(prop.formula, columns, table)} as ${aliased}`));
                 }
-                if (!prop.object && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL)) {
+                if (!prop.object && !prop.formula && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL)) {
                     ret.push(prop.name);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.2.5-dev.5",
+  "version": "7.2.5-dev.7",
   "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.2.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.5-dev.5"
+    "@mikro-orm/core": "7.2.5-dev.7"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/SchemaComparator.js

@@ -166,11 +166,12 @@ export class SchemaComparator {
                 diff.changedTables[viewName] = tableDiff;
             }
         }
-        this.compareRoutines(fromSchema, toSchema, diff);
+        this.compareRoutines(fromSchema, toSchema, diff, !!inverseDiff);
         return diff;
     }
-    compareRoutines(fromSchema, toSchema, diff) {
+    compareRoutines(fromSchema, toSchema, diff, inverse) {
         // `ignoreRoutines` makes routines create-only: new ones are still added, but existing routines are never diffed for drop/alter.
+        // The down diff (`inverse`) mirrors that: it drops what `up` created and never recreates routines unknown to the metadata.
         const ignoreRoutines = this.#platform.getConfig().get('schemaGenerator').ignoreRoutines;
         // Case-fold so user-written `'sql_hash'` matches Oracle's introspected `'SQL_HASH'`.
         const routineKey = (r) => ((r.schema ? `${r.schema}.` : '') + r.name).toLowerCase();
@@ -179,6 +180,9 @@ export class SchemaComparator {
         for (const [key, toRoutine] of toByKey) {
             const fromRoutine = fromByKey.get(key);
             if (!fromRoutine) {
+                if (ignoreRoutines && inverse) {
+                    continue;
+                }
                 diff.newRoutines[key] = toRoutine;
                 this.log(`routine ${key} added`);
                 continue;
@@ -188,7 +192,7 @@ export class SchemaComparator {
                 this.log(`routine ${key} changed`, { fromRoutine, toRoutine });
             }
         }
-        if (!ignoreRoutines) {
+        if (!ignoreRoutines || inverse) {
             for (const [key, fromRoutine] of fromByKey) {
                 if (!toByKey.has(key)) {
                     diff.removedRoutines[key] = fromRoutine;
@@ -493,10 +497,12 @@ export class SchemaComparator {
             tableDifferences.changedChecks[check.name] = toTableCheck;
             changes++;
         }
+        const ignoreTriggers = this.#platform.getConfig().get('schemaGenerator').ignoreTriggers;
         const fromTableTriggers = fromTable.getTriggers();
         const toTableTriggers = toTable.getTriggers();
         for (const trigger of toTableTriggers) {
-            if (fromTable.hasTrigger(trigger.name)) {
+            // see `compareRoutines` for how `ignoreTriggers` applies to the down diff
+            if (fromTable.hasTrigger(trigger.name) || (ignoreTriggers && inverse)) {
                 continue;
             }
             tableDifferences.addedTriggers[trigger.name] = trigger;
@@ -504,7 +510,7 @@ export class SchemaComparator {
             changes++;
         }
         // `ignoreTriggers` makes triggers create-only: declared ones are still added above, but existing triggers are never diffed for drop/alter.
-        if (!this.#platform.getConfig().get('schemaGenerator').ignoreTriggers) {
+        if (!ignoreTriggers || inverse) {
             for (const trigger of fromTableTriggers) {
                 if (!toTable.hasTrigger(trigger.name)) {
                     tableDifferences.removedTriggers[trigger.name] = trigger;
@@ -513,7 +519,7 @@ export class SchemaComparator {
                     continue;
                 }
                 const toTableTrigger = toTable.getTrigger(trigger.name);
-                if (this.diffTrigger(trigger, toTableTrigger)) {
+                if (!ignoreTriggers && this.diffTrigger(trigger, toTableTrigger)) {
                     this.log(`trigger ${trigger.name} changed in table ${tableDifferences.name}`, {
                         fromTableTrigger: trigger,
                         toTableTrigger,