@mikro-orm/core 7.2.4-dev.14 → 7.2.4-dev.16

package/EntityManager.js

@@ -1025,6 +1025,15 @@ export class EntityManager {
                     where[meta.primaryKeys[0]] = ret.insertId;
                 }
             }
+            // a `null` unique value cannot identify the row, and as it never conflicts, the row was inserted
+            if (!Utils.hasObjectKeys(where)) {
+                const insertId = meta.simplePK && ret.insertId != null ? { [meta.primaryKeys[0]]: ret.insertId } : {};
+                Object.assign(where, Utils.getPrimaryKeyCond(entity, meta.primaryKeys) ?? insertId);
+            }
+            // an empty condition would hydrate the entity from an arbitrary row, mongo still gets one for nested conflict fields
+            if (!Utils.hasObjectKeys(where) && platform.usesPivotTable()) {
+                throw new Error(`Cannot find the upserted ${meta.className} row, as neither its primary key nor a unique value is known`);
+            }
             const data2 = await em.withSessionContext(options.ctx ?? em.#transactionContext, ctx => this.driver.findOne(meta.class, where, {
                 fields: returning.concat(...(options.onConflictMergeFields ?? [])),
                 ctx,
@@ -1032,6 +1041,9 @@ export class EntityManager {
                 connectionType: 'write',
                 schema: options.schema,
             }));
+            if (!data2) {
+                throw new Error(`Cannot find the upserted ${meta.className} row for condition ${JSON.stringify(where)}`);
+            }
             em.getHydrator().hydrate(entity, meta, data2, em.#entityFactory, 'full', false, true);
         }
         // recompute the data as there might be some values missing (e.g. those with db column defaults)
@@ -1183,8 +1195,10 @@ export class EntityManager {
                     unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
             const tmp = getWhereCondition(meta, options.onConflictFields, row, where);
             propIndex = tmp.propIndex;
+            // a partial composite PK cannot identify the row
+            const partialPK = meta.compositePK && !Utils.isPlainObject(tmp.where) && meta.primaryKeys.some(pk => row[pk] == null);
             where = QueryHelper.processWhere({
-                where: tmp.where,
+                where: partialPK ? {} : tmp.where,
                 entityName,
                 metadata: this.metadata,
                 platform: this.getPlatform(),
@@ -1199,6 +1213,25 @@ export class EntityManager {
             allWhere.push(where);
             dataIndexes.push(i);
         }
+        // mongo inserts the rows with an empty condition as part of the batch and reports their ids
+        const positional = !this.getPlatform().usesPivotTable() ||
+            ((this.getPlatform().usesReturningStatement() || this.getPlatform().usesOutputStatement()) &&
+                options.onConflictAction !== 'ignore' &&
+                !options.onConflictWhere);
+        const hasUniqueKey = !!options.onConflictFields || meta.uniques.length > 0 || meta.props.some(p => p.unique && !p.primary);
+        // only an autoincrement PK can be derived from the `insertId` of the batch
+        const autoincrement = meta.getPrimaryProps().some(p => p.autoincrement);
+        // a TPT child table does not return its rows, so they are never mapped by position
+        const peel = !!meta.tptParent || (!positional && (hasUniqueKey || !autoincrement));
+        // a row with a `null` unique value has nothing to be reloaded by, the single row path maps its PK from the insert
+        for (let idx = 0; peel && idx < allWhere.length; idx++) {
+            if (!Utils.hasObjectKeys(allWhere[idx])) {
+                result[dataIndexes[idx]] = await em.upsert(entityName, data[dataIndexes[idx]], options);
+                allData.splice(idx, 1);
+                allWhere.splice(idx, 1);
+                dataIndexes.splice(idx--, 1);
+            }
+        }
         if (allData.length === 0) {
             return [...new Set(result)];
         }
@@ -1249,7 +1282,8 @@ export class EntityManager {
         // (onConflictWhere can suppress writes, leaving some rows out)
         // oxfmt-ignore
         const getUniqueFields = (where) => options.onConflictFields ?? (Utils.isPlainObject(where) ? Object.keys(where).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
-        const uniqueFields = getUniqueFields(allWhere[0]);
+        // a row without a condition has no unique fields to derive
+        const uniqueFields = getUniqueFields(allWhere.find(cond => Utils.hasObjectKeys(cond)) ?? allWhere[0]);
         // an empty condition identifies no row, it must not turn into a reload condition matching every row
         const getRowUniqueFields = (where) => Utils.isPlainObject(where) && !Utils.hasObjectKeys(where) ? uniqueFields : getUniqueFields(where);
         const platform = this.getPlatform();
@@ -1268,11 +1302,13 @@ export class EntityManager {
                 Utils.keys(cond).forEach(key => add.add(key));
             }
             const where = { $or: [] };
+            // a row without a condition was inserted, only the primary key reported for it can identify it
+            const insertedPKs = allData.map((row, idx) => Utils.hasObjectKeys(allWhere[idx]) ? null : Utils.getPrimaryKeyCond(entitiesByData.get(row), meta.primaryKeys));
             dataIndexes.forEach((index, idx) => {
                 const item = data[index];
-                where.$or[idx] = {};
+                where.$or[idx] = { ...insertedPKs[idx] };
                 // the inputs of one batch can be identified by different unique keys
-                const fields = getRowUniqueFields(allWhere[idx]);
+                const fields = insertedPKs[idx] ? [] : getRowUniqueFields(allWhere[idx]);
                 const props = Array.isArray(fields) ? fields : Object.keys(item);
                 props.forEach(prop => {
                     where.$or[idx][prop] = item[prop];
@@ -1299,10 +1335,8 @@ export class EntityManager {
                     });
                     return tmp;
                 });
-                // rows carry the keys of every condition in the batch, compare only this one's (an empty one must not match)
-                const isMatch = (cond, idx) => this.#comparator.matching(entityName, cond, Utils.hasObjectKeys(cond)
-                    ? Object.fromEntries(Object.entries(comparableRows[idx]).filter(([k]) => k in cond))
-                    : comparableRows[idx]);
+                // rows carry the keys of every condition in the batch, compare only this one's
+                const isMatch = (cond, idx) => this.#comparator.matching(entityName, cond, Object.fromEntries(Object.entries(comparableRows[idx]).filter(([k]) => k in cond)));
                 // When every condition key is a comparable prop checked with `!==`, a matching row has the same primitive
                 // values, so rows can be grouped by those values once instead of comparing every row for every entity.
                 // Props outside `comparableProps` are skipped by the comparator, so they never qualify for grouping.
@@ -1341,12 +1375,13 @@ export class EntityManager {
             if (loadPK.size !== data2.length && Array.isArray(uniqueFields)) {
                 for (let i = 0; i < allData.length; i++) {
                     const data = allData[i];
-                    const fields = getRowUniqueFields(allWhere[i]);
-                    const cond = fields.reduce((a, b) => {
-                        // @ts-ignore
-                        a[b] = data[b];
-                        return a;
-                    }, {});
+                    const fields = (insertedPKs[i] ? meta.primaryKeys : getRowUniqueFields(allWhere[i]));
+                    const cond = insertedPKs[i] ??
+                        fields.reduce((a, b) => {
+                            // @ts-ignore
+                            a[b] = data[b];
+                            return a;
+                        }, {});
                     const entity = entitiesByData.get(data);
                     const row = data2.find(item => {
                         const pk = fields.reduce((a, b) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.4-dev.14",
+  "version": "7.2.4-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",

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.2.4-dev.14';
+    static #ORM_VERSION = '7.2.4-dev.16';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;

package/utils/upsert-utils.js

@@ -103,7 +103,8 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options,
         if (p.lazy || p.embeddable) {
             return false;
         }
-        if (p.autoincrement) {
+        // a PK missing in the data is generated by the database
+        if (p.autoincrement || (p.primary && data[p.name] == null)) {
             return true;
         }
         // for a raw `onConflictFields` fragment we can't introspect which columns form the conflict