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

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.10",
   "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/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.10';
     /** 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()) {