@mikro-orm/core 7.2.4-dev.10 → 7.2.4-dev.12

package/EntityManager.js

@@ -1283,8 +1283,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,13 +1292,43 @@ 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)}`);
+                const isMatch = (cond, idx) => this.#comparator.matching(entityName, cond, comparableRows[idx]);
+                // 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++) {

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.10",
+  "version": "7.2.4-dev.12",
   "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.10';
+    static #ORM_VERSION = '7.2.4-dev.12';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;