@mikro-orm/sql 7.1.15-dev.8 → 7.1.15

package/AbstractSqlDriver.d.ts

@@ -118,13 +118,6 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[]): EntityData<T>[];
     protected shouldHaveColumn<T, U>(meta: EntityMetadata<T>, prop: EntityProperty<U>, populate: readonly PopulateOptions<U>[], fields?: readonly InternalField<U>[], exclude?: readonly InternalField<U>[]): boolean;
     protected getFieldsForJoinedLoad<T extends object>(qb: AnyQueryBuilder<T>, meta: EntityMetadata<T>, options: FieldsForJoinedLoadOptions<T>): InternalField<T>[];
-    /**
-     * Walks the TPT inheritance chain of `leafMeta` and INNER JOINs each parent table.
-     * Registers the parent aliases in `qb.state.tptAlias` so column resolution finds them
-     * when filter conditions reference parent-table columns.
-     * @internal
-     */
-    protected addTPTParentJoinsForRelation<T extends object>(qb: AnyQueryBuilder<T>, leafMeta: EntityMetadata, leafAlias: string, basePath: string): void;
     /**
      * Adds LEFT JOINs and fields for TPT polymorphic loading when populating a relation to a TPT base class.
      * @internal

package/AbstractSqlDriver.js

@@ -915,7 +915,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (!options.upsert && options.unionWhere?.length) {
             where = (await this.applyUnionWhere(meta, where, options, true));
         }
-        if (Utils.hasObjectKeys(data)) {
+        if (options.upsert && meta.tptParent) {
+            res = await this.nativeUpdateMany(entityName, [where], [data], options);
+        }
+        else if (Utils.hasObjectKeys(data) || (meta.inheritanceType === 'tpt' && meta.ownsVersionProperty())) {
+            // a TPT table declaring the version property is bumped even when only other tables of the hierarchy changed
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
             qb.setAbortOptions(pickAbortOptions(options));
             if (options.upsert) {
@@ -941,7 +945,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 qb.update(data).where(where);
                 // reload generated columns and version fields
                 const returning = [];
-                meta.props
+                this.getTableProps(meta)
                     .filter(prop => (prop.generated && !prop.primary) || prop.version)
                     .forEach(prop => returning.push(prop.name));
                 qb.returning(returning);
@@ -957,13 +961,38 @@ export class AbstractSqlDriver extends DatabaseDriver {
         options.convertCustomTypes ??= true;
         const meta = this.metadata.get(entityName);
         if (options.upsert) {
+            if (meta.tptParent) {
+                // TPT parent tables go first, the PK they provide is the conflict target of this table
+                await this.nativeUpdateMany(meta.tptParent.class, where, data, options);
+                for (const [i, row] of data.entries()) {
+                    if (meta.primaryKeys.some(pk => row[pk] == null)) {
+                        const found = await this.findOne(meta.tptParent.class, where[i], {
+                            fields: meta.primaryKeys,
+                            ctx: options.ctx,
+                            connectionType: 'write',
+                            schema: options.schema,
+                        });
+                        meta.primaryKeys.forEach(pk => (row[pk] = found?.[pk]));
+                    }
+                }
+                options = { ...options, onConflictFields: meta.primaryKeys, onConflictWhere: undefined };
+            }
             const uniqueFields = options.onConflictFields ??
                 (Utils.isPlainObject(where[0])
                     ? Object.keys(where[0]).flatMap(key => Utils.splitPrimaryKeys(key))
                     : meta.primaryKeys);
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes, options.loggerContext).withSchema(this.getSchemaName(meta, options));
             qb.setAbortOptions(pickAbortOptions(options));
-            const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
+            let returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
+            if (meta.inheritanceType === 'tpt') {
+                // each TPT table only carries its own columns, the entity is reloaded instead of mapping the returned rows
+                const own = (key) => meta.primaryKeys.includes(key) ||
+                    this.getTableProps(meta).some(prop => prop.name === key.split('.')[0]);
+                data = data.map(row => Object.fromEntries(Object.entries(row).filter(([key]) => own(key))));
+                options.onConflictMergeFields = options.onConflictMergeFields?.filter(f => own(f));
+                options.onConflictExcludeFields = options.onConflictExcludeFields?.filter(f => own(f));
+                returning = [];
+            }
             qb.insert(data)
                 .onConflict(uniqueFields)
                 .returning(returning);
@@ -977,7 +1006,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
             if (options.onConflictWhere) {
                 qb.where(options.onConflictWhere);
             }
-            return this.rethrow(qb.execute('run', false));
+            const res = await this.rethrow(qb.execute('run', false));
+            return meta.inheritanceType === 'tpt' ? { ...res, row: undefined, rows: [] } : res;
         }
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
         const keys = new Set();
@@ -992,7 +1022,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
         }
         // reload generated columns and version fields
-        meta.props.filter(prop => prop.generated || prop.version || prop.primary).forEach(prop => returning.add(prop.name));
+        meta.getPrimaryProps().forEach(prop => returning.add(prop.name));
+        this.getTableProps(meta)
+            .filter(prop => prop.generated || prop.version)
+            .forEach(prop => returning.add(prop.name));
         const pkCond = Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames))
             .map(pk => `${this.platform.quoteIdentifier(pk)} = ?`)
             .join(' and ');
@@ -1050,7 +1083,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 return sql;
             });
         }
-        if (meta.versionProperty) {
+        if (meta.ownsVersionProperty()) {
             const versionProperty = meta.properties[meta.versionProperty];
             const quotedFieldName = this.platform.quoteIdentifier(versionProperty.fieldNames[0]);
             sql += `${quotedFieldName} = `;
@@ -1063,7 +1096,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             sql += `, `;
         }
         sql = sql.substring(0, sql.length - 2) + ' where ';
-        const pkProps = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
+        const pkProps = meta.primaryKeys.concat(...meta.getOwnConcurrencyCheckKeys());
         const pks = Utils.flatten(pkProps.map(pk => meta.properties[pk].fieldNames));
         const useTupleIn = pks.length <= 1 || this.platform.allowsComparingTuples();
         const condTemplate = useTupleIn
@@ -1784,7 +1817,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     // INNER JOINs get nested inside the polymorphic LEFT JOIN by processNestedJoins, which
                     // keeps the resulting query valid for rows pointing to other polymorphic targets.
                     if (targetMeta.inheritanceType === 'tpt' && targetMeta.tptParent) {
-                        this.addTPTParentJoinsForRelation(qb, targetMeta, tableAlias, targetPath);
+                        qb.addTPTParentJoins(targetMeta, tableAlias, targetPath);
                     }
                     // For polymorphic targets that are TPT base classes, also LEFT JOIN
                     // all descendant tables so child-specific fields can be selected.
@@ -1832,10 +1865,6 @@ export class AbstractSqlDriver extends DatabaseDriver {
                         : JoinType.leftJoin;
             const schema = prop.targetMeta.schema === '*' ? (options?.schema ?? this.config.get('schema')) : prop.targetMeta.schema;
             qb.join(field, tableAlias, {}, joinType, path, schema);
-            // For relations to TPT child entities, INNER JOIN parent tables (GH #7469)
-            if (meta2.inheritanceType === 'tpt' && meta2.tptParent) {
-                this.addTPTParentJoinsForRelation(qb, meta2, tableAlias, path);
-            }
             // For relations to TPT base classes, add LEFT JOINs for all child tables (polymorphic loading)
             if (meta2.inheritanceType === 'tpt' && meta2.tptChildren?.length && !ref) {
                 // Use the registry metadata to ensure allTPTDescendants is available
@@ -1882,25 +1911,6 @@ export class AbstractSqlDriver extends DatabaseDriver {
         }
         return fields;
     }
-    /**
-     * Walks the TPT inheritance chain of `leafMeta` and INNER JOINs each parent table.
-     * Registers the parent aliases in `qb.state.tptAlias` so column resolution finds them
-     * when filter conditions reference parent-table columns.
-     * @internal
-     */
-    addTPTParentJoinsForRelation(qb, leafMeta, leafAlias, basePath) {
-        let childAlias = leafAlias;
-        let childMeta = leafMeta;
-        while (childMeta.tptParent) {
-            const parentMeta = childMeta.tptParent;
-            const parentAlias = qb.getNextAlias(parentMeta.className);
-            qb.createAlias(parentMeta.class, parentAlias);
-            qb.state.tptAlias[`${leafAlias}:${parentMeta.className}`] = parentAlias;
-            qb.addPropertyJoin(childMeta.tptParentProp, childAlias, parentAlias, JoinType.innerJoin, `${basePath}.[tpt]${childMeta.className}`);
-            childAlias = parentAlias;
-            childMeta = parentMeta;
-        }
-    }
     /**
      * Adds LEFT JOINs and fields for TPT polymorphic loading when populating a relation to a TPT base class.
      * @internal

package/package.json

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

package/query/QueryBuilder.d.ts

@@ -950,6 +950,13 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     addPropertyJoin(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, path: string, schema?: string): string;
     private joinReference;
+    /**
+     * Walks the TPT inheritance chain of `leafMeta` and INNER JOINs each parent table.
+     * Registers the parent aliases in `state.tptAlias` so column resolution finds them
+     * when conditions reference parent-table columns.
+     * @internal
+     */
+    addTPTParentJoins(leafMeta: EntityMetadata, leafAlias: string, basePath: string): void;
     protected prepareFields<T>(fields: InternalField<T>[], type?: 'where' | 'groupBy' | 'sub-query', schema?: string): (string | RawQueryFragment)[];
     /**
      * Resolves nested paths like `a.books.title` to their actual field references.

package/query/QueryBuilder.js

@@ -495,7 +495,10 @@ export class QueryBuilder {
             return cond.some(c => this.condReferencesAlias(c, alias));
         }
         if (Utils.isPlainObject(cond)) {
-            return Object.entries(cond).some(([key, value]) => key.startsWith(`${alias}.`) || this.condReferencesAlias(value, alias));
+            return Object.entries(cond).some(([key, value]) => {
+                const [keyAlias, field] = this.helper.splitField(key);
+                return this.helper.getTPTAliasForProperty(field, keyAlias) === alias || this.condReferencesAlias(value, alias);
+            });
         }
         return false;
     }
@@ -904,6 +907,8 @@ export class QueryBuilder {
         if (this.type === QueryType.INSERT) {
             const returningProps = meta.hydrateProps
                 .filter(prop => prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)))
+                // a TPT table can only return its own columns
+                .filter(prop => meta.inheritanceType !== 'tpt' || prop.primary || meta.ownProps.some(p => p.name === prop.name))
                 .filter(prop => !data || !(prop.name in data));
             if (returningProps.length > 0) {
                 qb.returning(Utils.flatten(returningProps.map(prop => prop.fieldNames)));
@@ -1493,9 +1498,31 @@ export class QueryBuilder {
             this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(prop, ownerAlias, alias, type, cond, schema);
             this.#state.joins[aliasedName].path ??= path;
         }
+        if (prop.targetMeta.inheritanceType === 'tpt' && prop.targetMeta.tptParent) {
+            this.addTPTParentJoins(prop.targetMeta, alias, path);
+        }
         this.nestReferencedJoins(this.#state.joins[aliasedName]);
         return { prop, key: aliasedName };
     }
+    /**
+     * Walks the TPT inheritance chain of `leafMeta` and INNER JOINs each parent table.
+     * Registers the parent aliases in `state.tptAlias` so column resolution finds them
+     * when conditions reference parent-table columns.
+     * @internal
+     */
+    addTPTParentJoins(leafMeta, leafAlias, basePath) {
+        let childAlias = leafAlias;
+        let childMeta = leafMeta;
+        while (childMeta.tptParent) {
+            const parentMeta = childMeta.tptParent;
+            const parentAlias = this.getNextAlias(parentMeta.className);
+            this.createAlias(parentMeta.class, parentAlias);
+            this.#state.tptAlias[`${leafAlias}:${parentMeta.className}`] = parentAlias;
+            this.addPropertyJoin(childMeta.tptParentProp, childAlias, parentAlias, JoinType.innerJoin, `${basePath}.[tpt]${childMeta.className}`);
+            childAlias = parentAlias;
+            childMeta = parentMeta;
+        }
+    }
     prepareFields(fields, type = 'where', schema) {
         const ret = [];
         const getFieldName = (name, customAlias) => {
@@ -2085,6 +2112,7 @@ export class QueryBuilder {
                 else {
                     join.cond = { ...join.cond, [k]: cond[k] };
                 }
+                this.nestReferencedJoins(join);
             }
         }
     }

package/query/QueryBuilderHelper.js

@@ -763,7 +763,7 @@ export class QueryBuilderHelper {
     }
     updateVersionProperty(qb, data) {
         const meta = this.#metadata.find(this.#entityName);
-        if (!meta?.versionProperty || meta.versionProperty in data) {
+        if (!meta?.ownsVersionProperty() || meta.versionProperty in data) {
             return;
         }
         const versionProperty = meta.properties[meta.versionProperty];