@mikro-orm/sql 7.2.5-dev.1 → 7.2.5-dev.11

package/AbstractSqlDriver.d.ts

@@ -127,6 +127,12 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      * @internal
      */
     protected addTPTPolymorphicJoinsForRelation<T extends object>(qb: AnyQueryBuilder<T>, meta: EntityMetadata<T>, baseAlias: string, fields: InternalField<T>[]): void;
+    /**
+     * Registers the ancestor table aliases of each polymorphically joined TPT descendant,
+     * so formulas on descendants resolve inherited columns to the table that owns them.
+     * @internal
+     */
+    registerTPTAncestorAliases(qb: AnyQueryBuilder<any>, meta: EntityMetadata, baseAlias: string, childAliases: Dictionary<string>): void;
     /**
      * Find the alias for a TPT child table in the query builder.
      * @internal

package/AbstractSqlDriver.js

@@ -853,10 +853,16 @@ export class AbstractSqlDriver extends DatabaseDriver {
                         // the map misses subtypes whose props were not initialized yet during discovery (root column owner, grandchildren)
                         const discriminator = row[meta.discriminatorColumn];
                         const childClass = meta.discriminatorMap?.[discriminator];
-                        const activeField = prop.stiFieldNameMap[discriminator] ??
-                            (childClass && this.metadata.find(childClass)?.properties[prop.name]?.fieldNames[0]);
+                        const childProp = childClass && this.metadata.find(childClass)?.properties[prop.name];
+                        const activeField = prop.stiFieldNameMap[discriminator] ?? childProp?.fieldNames[0];
                         for (const field of prop.stiFieldNames) {
-                            params.push(field === activeField ? (row[prop.name] ?? null) : null);
+                            // the subtype's own property, as siblings can declare it with a different type or embeddable
+                            if (field === activeField) {
+                                addParams(childProp ?? prop, row);
+                            }
+                            else {
+                                params.push(null);
+                            }
                             keys.push('?');
                         }
                         return;
@@ -1989,6 +1995,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
             qb.createAlias(childMeta.class, childAlias);
             childAliases[childMeta.className] = childAlias;
             qb.addPropertyJoin(childMeta.tptInverseProp, baseAlias, childAlias, JoinType.leftJoin, `[tpt]${meta.className}`);
+        }
+        this.registerTPTAncestorAliases(qb, meta, baseAlias, childAliases);
+        for (const childMeta of descendants) {
+            const childAlias = childAliases[childMeta.className];
             // Add fields from this child (only ownProps, skip PKs)
             const schema = childMeta.schema === '*' ? '*' : this.getSchemaName(childMeta);
             childMeta
@@ -2000,6 +2010,21 @@ export class AbstractSqlDriver extends DatabaseDriver {
             fields.push(this.buildTPTDiscriminatorExpression(meta, descendants, childAliases, baseAlias));
         }
     }
+    /**
+     * Registers the ancestor table aliases of each polymorphically joined TPT descendant,
+     * so formulas on descendants resolve inherited columns to the table that owns them.
+     * @internal
+     */
+    registerTPTAncestorAliases(qb, meta, baseAlias, childAliases) {
+        const tptAlias = qb.state.tptAlias;
+        for (const childMeta of meta.allTPTDescendants) {
+            for (let parent = childMeta.tptParent; parent; parent = parent.tptParent) {
+                tptAlias[`${childAliases[childMeta.className]}:${parent.className}`] =
+                    childAliases[parent.className] ??
+                        (parent === meta ? baseAlias : tptAlias[`${baseAlias}:${parent.className}`]);
+            }
+        }
+    }
     /**
      * Find the alias for a TPT child table in the query builder.
      * @internal
@@ -2087,6 +2112,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(p => qb.helper.getTPTAliasForProperty(p.name, tableAlias), 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 +2132,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 +2552,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.1",
+  "version": "7.2.5-dev.11",
   "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.1"
+    "@mikro-orm/core": "7.2.5-dev.11"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.js

@@ -1873,20 +1873,7 @@ export class QueryBuilder {
         if (meta.root.inheritanceType !== 'sti' || !meta.discriminatorValue) {
             return;
         }
-        const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.get(cls));
-        const children = [];
-        const lookUpChildren = (ret, parent) => {
-            const children = types.filter(meta2 => meta2.extends && this.metadata.find(meta2.extends) === parent);
-            children.forEach(m => lookUpChildren(ret, m));
-            ret.push(...children.filter(c => c.discriminatorValue));
-            return children;
-        };
-        lookUpChildren(children, meta);
-        this.andWhere({
-            [meta.root.discriminatorColumn]: children.length > 0
-                ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] }
-                : meta.discriminatorValue,
-        });
+        this.andWhere({ [meta.root.discriminatorColumn]: this.helper.getDiscriminatorCondition(meta) });
     }
     /**
      * Ensures TPT joins are applied. Can be called early before finalize() to populate
@@ -1943,7 +1930,8 @@ export class QueryBuilder {
             if (parentAlias) {
                 const schema = parentMeta.schema === '*' ? '*' : this.driver.getSchemaName(parentMeta);
                 parentMeta
-                    .ownProps.filter(prop => this.platform.shouldHaveColumn(prop, []))
+                    // inherited formulas are selected on the main alias in `finalize()`
+                    .ownProps.filter(prop => !prop.formula && this.platform.shouldHaveColumn(prop, []))
                     .forEach(prop => this.#state.fields.push(...this.driver.mapPropToFieldNames(this, prop, parentAlias, parentMeta, schema)));
             }
             parentMeta = parentMeta.tptParent;
@@ -1962,12 +1950,16 @@ export class QueryBuilder {
         if (!this.#state.fields?.includes('*') && !this.#state.fields?.includes(`${this.mainAlias.aliasName}.*`)) {
             return;
         }
-        // LEFT JOIN each descendant table and add their fields
+        // LEFT JOIN each descendant table
         for (const childMeta of descendants) {
             const childAlias = this.getNextAlias(childMeta.className);
             this.createAlias(childMeta.class, childAlias);
             this.#state.tptAlias[childMeta.className] = childAlias;
             this.addPropertyJoin(childMeta.tptInverseProp, this.mainAlias.aliasName, childAlias, JoinType.leftJoin, `[tpt]${meta.className}`);
+        }
+        this.driver.registerTPTAncestorAliases(this, meta, this.mainAlias.aliasName, this.#state.tptAlias);
+        for (const childMeta of descendants) {
+            const childAlias = this.#state.tptAlias[childMeta.className];
             // Add child fields
             const schema = childMeta.schema === '*' ? '*' : this.driver.getSchemaName(childMeta);
             childMeta
@@ -1976,7 +1968,7 @@ export class QueryBuilder {
         }
         // Add computed discriminator (CASE WHEN to determine concrete type)
         // descendants is pre-sorted by depth (deepest first) during discovery
-        if (meta.tptDiscriminatorColumn) {
+        if (meta.root.tptDiscriminatorColumn) {
             this.#state.fields.push(this.driver.buildTPTDiscriminatorExpression(meta, descendants, this.#state.tptAlias, this.mainAlias.aliasName));
         }
     }

package/query/QueryBuilderHelper.d.ts

@@ -30,6 +30,8 @@ export declare class QueryBuilderHelper {
         sql: string;
         params: unknown[];
     };
+    /** STI discriminator condition matching the entity and all its subclasses. */
+    getDiscriminatorCondition(meta: EntityMetadata): unknown;
     mapJoinColumns(type: QueryType, join: JoinOptions): (string | Raw)[];
     isOneToOneInverse(field: string, meta?: EntityMetadata): boolean;
     getTableName(entityName: EntityName): string;

package/query/QueryBuilderHelper.js

@@ -296,7 +296,7 @@ export class QueryBuilderHelper {
             !join.path?.endsWith('[pivot]')) {
             const typeProperty = join.prop.targetMeta.root.discriminatorColumn;
             const alias = join.inverseAlias ?? join.alias;
-            join.cond[`${alias}.${typeProperty}`] = join.prop.targetMeta.discriminatorValue;
+            join.cond[`${alias}.${typeProperty}`] = this.getDiscriminatorCondition(join.prop.targetMeta);
         }
         // For polymorphic relations, add discriminator condition to filter by target entity type
         if (join.prop.polymorphic && join.prop.discriminatorColumn && join.prop.discriminatorMap) {
@@ -341,6 +341,22 @@ export class QueryBuilderHelper {
         }
         return { sql, params };
     }
+    /** STI discriminator condition matching the entity and all its subclasses. */
+    getDiscriminatorCondition(meta) {
+        const types = Object.values(meta.root.discriminatorMap).map(cls => this.#metadata.get(cls));
+        const children = [];
+        const lookUpChildren = (ret, parent) => {
+            const children = types.filter(meta2 => meta2.extends && this.#metadata.find(meta2.extends) === parent);
+            children.forEach(m => lookUpChildren(ret, m));
+            ret.push(...children.filter(c => c.discriminatorValue));
+            return children;
+        };
+        // resolve from storage, `prop.targetMeta` can be a copy that fails the identity check above
+        lookUpChildren(children, this.#metadata.get(meta.class));
+        return children.length > 0
+            ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] }
+            : meta.discriminatorValue;
+    }
     mapJoinColumns(type, join) {
         if (join.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(join.prop.kind)) {
             return join.prop.fieldNames.map((_fieldName, idx) => {

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,