@mikro-orm/core 7.2.4-dev.9 → 7.2.5-dev.0

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)];
         }
@@ -1248,7 +1281,11 @@ export class EntityManager {
         // skip the reload only when RETURNING brought back a row for every input
         // (onConflictWhere can suppress writes, leaving some rows out)
         // oxfmt-ignore
-        const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(allWhere[0]) ? Object.keys(allWhere[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
+        const getUniqueFields = (where) => options.onConflictFields ?? (Utils.isPlainObject(where) ? Object.keys(where).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
+        // 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();
         const returning = getOnConflictReturningFields(meta, data[dataIndexes[0]], uniqueFields, options, platform);
         if (options.onConflictWhere && res.rows?.length !== allData.length) {
@@ -1265,10 +1302,14 @@ 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] = {};
-                const props = Array.isArray(uniqueFields) ? uniqueFields : Object.keys(item);
+                where.$or[idx] = { ...insertedPKs[idx] };
+                // the inputs of one batch can be identified by different unique keys
+                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];
                 });
@@ -1283,8 +1324,8 @@ export class EntityManager {
                 connectionType: 'write',
                 schema: options.schema,
             }));
-            for (const [entity, cond] of loadPK.entries()) {
-                const row = data2.find(row => {
+            if (loadPK.size > 0) {
+                const comparableRows = data2.map(row => {
                     const tmp = {};
                     add.forEach(k => {
                         const prop = meta.properties[k];
@@ -1292,25 +1333,58 @@ export class EntityManager {
                             tmp[k] = prop?.customType ? prop.customType.convertToDatabaseValue(row[k], this.getPlatform()) : row[k];
                         }
                     });
-                    return this.#comparator.matching(entityName, cond, tmp);
+                    return tmp;
                 });
-                /* v8 ignore next */
-                if (!row) {
-                    throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
+                // 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.
+                const groupableProps = new Set(meta.comparableProps.filter(prop => this.#comparator.isStrictlyCompared(prop)));
+                const groups = new Map();
+                // `null` and `undefined` share a key, which can only make a group wider than what `matching` accepts
+                const groupKey = (data, keys) => keys.map(k => (data[k] == null ? 'null' : `${typeof data[k]}:${data[k]}`)).join('\0');
+                const findRowIndex = (cond) => {
+                    const keys = Utils.keys(cond);
+                    if (!keys.every(k => groupableProps.has(meta.properties[k]))) {
+                        return comparableRows.findIndex((_, idx) => isMatch(cond, idx));
+                    }
+                    const signature = keys.join('\0');
+                    if (!groups.has(signature)) {
+                        const rowsByKey = new Map();
+                        comparableRows.forEach((tmp, idx) => {
+                            const rowKey = groupKey(tmp, keys);
+                            const indexes = rowsByKey.get(rowKey) ?? [];
+                            indexes.push(idx);
+                            rowsByKey.set(rowKey, indexes);
+                        });
+                        groups.set(signature, rowsByKey);
+                    }
+                    const group = groups.get(signature);
+                    return group.get(groupKey(cond, keys))?.find(idx => isMatch(cond, idx)) ?? -1;
+                };
+                for (const [entity, cond] of loadPK.entries()) {
+                    const row = data2[findRowIndex(cond)];
+                    /* v8 ignore next */
+                    if (!row) {
+                        throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
+                    }
+                    em.getHydrator().hydrate(entity, meta, row, em.#entityFactory, 'full', false, true);
                 }
-                em.getHydrator().hydrate(entity, meta, row, em.#entityFactory, 'full', false, true);
             }
             if (loadPK.size !== data2.length && Array.isArray(uniqueFields)) {
                 for (let i = 0; i < allData.length; i++) {
                     const data = allData[i];
-                    const cond = uniqueFields.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 = uniqueFields.reduce((a, b) => {
+                        const pk = fields.reduce((a, b) => {
                             // @ts-ignore
                             a[b] = item[b];
                             return a;

package/entity/EntityLoader.js

@@ -325,11 +325,12 @@ export class EntityLoader {
         }
         else {
             // owning side of M:N without pivot table needs to be reordered
+            const childIndex = new Map(children.map((child, idx) => [child, idx]));
             for (const entity of filtered) {
-                const order = !customOrder ? [...entity[prop.name].getItems(false)] : []; // copy order of references
-                const items = children.filter(child => entity[prop.name].contains(child, false));
-                if (!customOrder) {
-                    items.sort((a, b) => order.indexOf(a) - order.indexOf(b));
+                // keep the order of references, or the order of loaded children when a custom order is used
+                const items = entity[prop.name].getItems(false).filter(item => childIndex.has(item));
+                if (customOrder) {
+                    items.sort((a, b) => childIndex.get(a) - childIndex.get(b));
                 }
                 entity[field].hydrate(items, true, partial, readonly);
             }

package/entity/defineEntity.d.ts

@@ -641,7 +641,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         '~discriminatorColumn'?: TBaseDiscriminatorColumn;
     });
     properties: TProperties | ((properties: PropertyBuilders) => TProperties);
-    primaryKeys?: TPK & InferPrimaryKeyConstraint<TProperties>[];
+    primaryKeys?: TPK & NoInfer<InferPrimaryKeyConstraint<TProperties>>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
     filters?: Dictionary<{
@@ -667,16 +667,16 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     /** Alias for `discriminator`. */
     discriminatorColumn?: TDiscriminatorColumn;
     discriminatorValue?: TDiscriminatorValue;
-    versionProperty?: AllKeys<TProperties, TBase>;
-    concurrencyCheckKeys?: Set<AllKeys<TProperties, TBase>>;
-    serializedPrimaryKey?: AllKeys<TProperties, TBase>;
+    versionProperty?: NoInfer<AllKeys<TProperties, TBase>>;
+    concurrencyCheckKeys?: Set<NoInfer<AllKeys<TProperties, TBase>>>;
+    serializedPrimaryKey?: NoInfer<AllKeys<TProperties, TBase>>;
     indexes?: {
         properties?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         name?: string;
         type?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
-        where?: PartialWhere<TProperties, TBase>;
+        where?: NoInfer<PartialWhere<TProperties, TBase>>;
         columns?: IndexColumnOptions[];
         include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         fillFactor?: number;
@@ -689,7 +689,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         name?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
-        where?: PartialWhere<TProperties, TBase>;
+        where?: NoInfer<PartialWhere<TProperties, TBase>>;
         deferMode?: DeferMode | `${DeferMode}`;
         columns?: IndexColumnOptions[];
         include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.4-dev.9",
+  "version": "7.2.5-dev.0",
   "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/EntityComparator.d.ts

@@ -19,6 +19,11 @@ export declare class EntityComparator {
     diffEntities<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>, options?: {
         includeInverseSides?: boolean;
     }): EntityData<T>;
+    /**
+     * Returns true if the comparator checks this property with `!==`, so matching values are identical primitives.
+     * @internal
+     */
+    isStrictlyCompared<T>(prop: EntityProperty<T>): boolean;
     /** Returns true if two entity snapshots are identical (no differences). */
     matching<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>): boolean;
     /**

package/utils/EntityComparator.js

@@ -29,6 +29,17 @@ export class EntityComparator {
         const comparator = this.getEntityComparator(entityName);
         return Utils.callCompiledFunction(comparator, a, b, options);
     }
+    /**
+     * Returns true if the comparator checks this property with `!==`, so matching values are identical primitives.
+     * @internal
+     */
+    isStrictlyCompared(prop) {
+        if (prop.kind !== ReferenceKind.SCALAR || prop.customType?.compareValues) {
+            return false;
+        }
+        const type = (prop.customType ? prop.customType.compareAsType() : prop.type).toLowerCase();
+        return ['string', 'number', 'bigint'].includes(type);
+    }
     /** Returns true if two entity snapshots are identical (no differences). */
     matching(entityName, a, b) {
         const diff = this.diffEntities(entityName, a, b);

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.9';
+    static #ORM_VERSION = '7.2.5-dev.0';
     /** 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