@mikro-orm/core 7.2.4-dev.1 → 7.2.4-dev.11

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/EntityLoader.js

@@ -312,18 +312,25 @@ export class EntityLoader {
     }
     initializeManyToMany(filtered, children, prop, field, customOrder, partial, readonly) {
         if (prop.mappedBy) {
+            // group children by owner in one pass
+            const map = new Map(filtered.map(entity => [entity, []]));
+            for (const child of children) {
+                for (const owner of child[prop.mappedBy].getItems(false)) {
+                    map.get(owner)?.push(child);
+                }
+            }
             for (const entity of filtered) {
-                const items = children.filter(child => child[prop.mappedBy].contains(entity, false));
-                entity[field].hydrate(items, true, partial, readonly);
+                entity[field].hydrate(map.get(entity), true, partial, readonly);
             }
         }
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.4-dev.1",
+  "version": "7.2.4-dev.11",
   "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/unit-of-work/ChangeSetPersister.js

@@ -196,10 +196,17 @@ export class ChangeSetPersister {
     }
     async persistManagedEntities(meta, changeSets, options) {
         const size = this.#config.get('batchSize');
-        for (let i = 0; i < changeSets.length; i += size) {
-            const chunk = changeSets.slice(i, i + size);
-            await this.persistManagedEntitiesBatch(meta, chunk, options);
-            await this.reloadVersionValues(meta, chunk, options);
+        // a batch checks the version in all rows or none, so references without a loaded version go separately
+        const hasVersion = (cs) => cs.entity[meta.versionProperty] != null;
+        const groups = meta.ownsVersionProperty()
+            ? [changeSets.filter(hasVersion), changeSets.filter(cs => !hasVersion(cs))]
+            : [changeSets];
+        for (const group of groups) {
+            for (let i = 0; i < group.length; i += size) {
+                const chunk = group.slice(i, i + size);
+                await this.persistManagedEntitiesBatch(meta, chunk, options);
+                await this.reloadVersionValues(meta, chunk, options);
+            }
         }
     }
     checkConcurrencyKeys(meta, changeSet, cond) {
@@ -223,9 +230,14 @@ export class ChangeSetPersister {
         });
         const cond = [];
         const payload = [];
+        // like in `updateEntity()`, but the batch needs the version in all rows or none
+        const versioned = meta.ownsVersionProperty() && changeSets.every(cs => cs.entity[meta.versionProperty] != null);
         for (const changeSet of changeSets) {
             const where = changeSet.getPrimaryKey(true);
             this.checkConcurrencyKeys(meta, changeSet, where);
+            if (versioned) {
+                where[meta.versionProperty] = this.#platform.convertVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+            }
             cond.push(where);
             payload.push(changeSet.payload);
         }
@@ -235,6 +247,12 @@ export class ChangeSetPersister {
         // from those to be able to match them with `getSerializedPrimaryKey()` of the entity
         const pkFields = meta.getPrimaryProps().flatMap(prop => prop.fieldNames);
         res.rows?.forEach(item => map.set(Utils.getPrimaryKeyHash(pkFields.map(field => item[field])), item));
+        if ((meta.ownsVersionProperty() || meta.getOwnConcurrencyCheckKeys().length > 0) &&
+            res.affectedRows < changeSets.length) {
+            // without `returning`, the stale entity can't be identified, so we report the first one
+            const failed = changeSets.find(cs => !map.has(helper(cs.entity).getSerializedPrimaryKey())) ?? changeSets[0];
+            throw OptimisticLockError.lockFailed(failed.entity);
+        }
         for (const changeSet of changeSets) {
             if (res.rows) {
                 const row = map.get(helper(changeSet.entity).getSerializedPrimaryKey());

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

package/utils/fs-utils.js

@@ -5,7 +5,8 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Utils } from './Utils.js';
 import { colors } from '../logging/colors.js';
 let globSync = (patterns, options) => {
-    const files = nodeGlobSync(patterns, { ...options, withFileTypes: true });
+    const cwd = options?.dir ? join(options.cwd ?? '', options.dir) : options?.cwd;
+    const files = nodeGlobSync(patterns, { cwd, withFileTypes: true });
     return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
 };
 export const fs = {
@@ -13,7 +14,8 @@ export const fs = {
         const tinyGlobby = await import('tinyglobby').catch(() => null);
         if (tinyGlobby) {
             globSync = (patterns, options) => {
-                patterns = Utils.asArray(patterns).map(p => p.replace(/\\/g, '/'));
+                const dir = options?.dir ? tinyGlobby.escapePath(options.dir.replace(/\\/g, '/')) + '/' : '';
+                patterns = Utils.asArray(patterns).map(p => dir + p.replace(/\\/g, '/'));
                 // never forward `cwd: undefined` — tinyglobby >= 0.2.16 calls `path.resolve(undefined)` and throws
                 return tinyGlobby.globSync(patterns, {
                     expandDirectories: false,
@@ -23,10 +25,10 @@ export const fs = {
         }
     },
     pathExists(path) {
-        if (/[*?[\]]/.test(path)) {
-            return globSync(path).length > 0;
+        if (existsSync(path)) {
+            return true;
         }
-        return existsSync(path);
+        return /[*?[\]]/.test(path) && this.resolveGlob(path).length > 0;
     },
     ensureDir(path) {
         if (!existsSync(path)) {
@@ -62,18 +64,20 @@ export const fs = {
         if (Array.isArray(input)) {
             return input.flatMap(paths => this.resolveGlob(paths, cwd));
         }
-        const hasGlobChars = /[*?[\]]/.test(input);
-        if (!hasGlobChars) {
-            try {
-                const s = statSync(cwd ? this.normalizePath(cwd, input) : input);
-                if (s.isDirectory()) {
-                    return globSync(join(input, '**'), { cwd });
-                }
-            }
-            catch {
-                // ignore
+        // an absolute path repeats the cwd, which may contain glob characters (e.g. `~/Dropbox (Team)/app`)
+        if (isAbsolute(input)) {
+            cwd ??= process.cwd();
+            input = relative(cwd, input).replace(/\\/g, '/') || '.';
+        }
+        try {
+            const s = statSync(cwd ? this.normalizePath(cwd, input) : input);
+            if (s.isDirectory()) {
+                return globSync('**', { cwd, dir: input });
             }
         }
+        catch {
+            // ignore
+        }
         return globSync(input, { cwd });
     },
     getPackageConfig(basePath = process.cwd()) {