@mikro-orm/sql 7.1.15-dev.15 → 7.1.15-dev.16

package/AbstractSqlDriver.js

@@ -915,8 +915,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (!options.upsert && options.unionWhere?.length) {
             where = (await this.applyUnionWhere(meta, where, options, true));
         }
-        // a TPT table declaring the version property is bumped even when only other tables of the hierarchy changed
-        if (Utils.hasObjectKeys(data) || (meta.inheritanceType === 'tpt' && meta.ownsVersionProperty())) {
+        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) {
@@ -958,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);
@@ -978,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();

package/package.json

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

package/query/QueryBuilder.js

@@ -904,6 +904,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)));