@mikro-orm/core 6.4.14 → 6.4.15-dev.1

package/EntityManager.d.ts

@@ -1,7 +1,7 @@
 import { inspect } from 'node:util';
 import DataLoader from 'dataloader';
 import { type Configuration, Cursor } from './utils';
-import { type AssignOptions, EntityFactory, type EntityLoaderOptions, type EntityRepository, EntityValidator, Reference } from './entity';
+import { type AssignOptions, EntityFactory, EntityLoader, type EntityLoaderOptions, type EntityRepository, EntityValidator, Reference } from './entity';
 import { UnitOfWork } from './unit-of-work';
 import type { CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from './drivers';
 import type { AnyEntity, AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityData, EntityDictionary, EntityDTO, EntityMetadata, EntityName, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MaybePromise, MergeLoaded, MergeSelected, NoInfer, ObjectQuery, Primary, Ref, RequiredEntityData, UnboxArray } from './typings';
@@ -430,6 +430,10 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * Gets the EntityFactory used by the EntityManager.
      */
     getEntityFactory(): EntityFactory;
+    /**
+     * @internal use `em.populate()` as the user facing API, this is exposed only for internal usage
+     */
+    getEntityLoader(): EntityLoader;
     /**
      * Gets the Hydrator used by the EntityManager.
      */

package/EntityManager.js

@@ -1449,6 +1449,12 @@ class EntityManager {
     getEntityFactory() {
         return this.getContext().entityFactory;
     }
+    /**
+     * @internal use `em.populate()` as the user facing API, this is exposed only for internal usage
+     */
+    getEntityLoader() {
+        return this.getContext().entityLoader;
+    }
     /**
      * Gets the Hydrator used by the EntityManager.
      */

package/entity/Collection.d.ts

@@ -2,7 +2,7 @@ import type { EntityDTO, EntityKey, FilterQuery, Loaded, LoadedCollection, Popul
 import { ArrayCollection } from './ArrayCollection';
 import { Reference } from './Reference';
 import type { Transaction } from '../connections/Connection';
-import type { FindOptions, CountOptions } from '../drivers/IDatabaseDriver';
+import type { CountOptions, FindOptions } from '../drivers/IDatabaseDriver';
 import type { EntityLoaderOptions } from './EntityLoader';
 export interface MatchingOptions<T extends object, P extends string = never> extends FindOptions<T, P> {
     where?: FilterQuery<T>;

package/entity/Collection.js

@@ -229,8 +229,13 @@ class Collection extends ArrayCollection_1.ArrayCollection {
                 this,
                 { ...options, orderBy },
             ]);
-            if (!customOrder) {
-                this.reorderItems(items, order);
+            if (this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+                this.initialized = true;
+                this.dirty = false;
+                if (!customOrder) {
+                    this.reorderItems(items, order);
+                }
+                return this;
             }
             this.items.clear();
             let i = 0;

package/entity/EntityLoader.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionType, Dictionary, FilterQuery, PopulateOptions } from '../typings';
+import type { AnyEntity, ConnectionType, Dictionary, EntityProperty, FilterQuery, PopulateOptions } from '../typings';
 import type { EntityManager } from '../EntityManager';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums';
 import type { EntityField } from '../drivers/IDatabaseDriver';
@@ -49,7 +49,8 @@ export declare class EntityLoader {
     private findChildren;
     private mergePrimaryCondition;
     private populateField;
-    private findChildrenFromPivotTable;
+    /** @internal */
+    findChildrenFromPivotTable<Entity extends object>(filtered: Entity[], prop: EntityProperty<Entity>, options: Required<EntityLoaderOptions<Entity>>, orderBy?: QueryOrderMap<Entity>[], populate?: PopulateOptions<Entity>, pivotJoin?: boolean): Promise<AnyEntity[][]>;
     private extractChildCondition;
     private buildFields;
     private getChildReferences;

package/entity/EntityLoader.js

@@ -144,7 +144,8 @@ class EntityLoader {
             .filter(orderBy => (Array.isArray(orderBy[prop.name]) && orderBy[prop.name].length > 0) || Utils_1.Utils.isObject(orderBy[prop.name]))
             .flatMap(orderBy => orderBy[prop.name]);
         if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && this.driver.getPlatform().usesPivotTable()) {
-            return this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
+            const res = await this.findChildrenFromPivotTable(filtered, prop, options, innerOrderBy, populate, !!ref);
+            return Utils_1.Utils.flatten(res);
         }
         const where = await this.extractChildCondition(options, prop);
         const data = await this.findChildren(entities, prop, populate, { ...options, where, orderBy: innerOrderBy }, !!(ref || prop.mapToPk));
@@ -342,6 +343,7 @@ class EntityLoader {
             visited: options.visited,
         });
     }
+    /** @internal */
     async findChildrenFromPivotTable(filtered, prop, options, orderBy, populate, pivotJoin) {
         const ids = filtered.map(e => e.__helper.__primaryKeys);
         const refresh = options.refresh;
@@ -379,7 +381,7 @@ class EntityLoader {
                 return this.em.getUnitOfWork().register(entity, item, { refresh, loaded: true });
             });
             entity[prop.name].hydrate(items, true);
-            children.push(...items);
+            children.push(items);
         }
         return children;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.14",
+  "version": "6.4.15-dev.1",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.4.14",
+    "mikro-orm": "6.4.15-dev.1",
     "reflect-metadata": "0.2.2"
   }
 }

package/utils/DataloaderUtils.js

@@ -5,6 +5,7 @@ const Collection_1 = require("../entity/Collection");
 const wrap_1 = require("../entity/wrap");
 const enums_1 = require("../enums");
 const Reference_1 = require("../entity/Reference");
+const Utils_1 = require("./Utils");
 class DataloaderUtils {
     /**
      * Groups identified references by entity and returns a Map with the
@@ -121,7 +122,6 @@ class DataloaderUtils {
                 // We need to populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s)
                 populate: [
                     ...(opts.populate === false ? [] : opts.populate ?? []),
-                    ...(opts.ref ? [':ref'] : []),
                     ...Array.from(filterMap.keys()).filter(
                     // We need to do so only if the inverse side is a collection, because we can already retrieve the PK from a reference without having to load it
                     prop => em.getMetadata(className).properties[prop]?.ref !== true),
@@ -152,10 +152,6 @@ class DataloaderUtils {
             else if (target) {
                 return target === collection.owner;
             }
-            // FIXME https://github.com/mikro-orm/mikro-orm/issues/6031
-            if (!target && collection.property.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
-                throw new Error(`Inverse side is required for M:N relations with dataloader: ${collection.owner.constructor.name}.${collection.property.name}`);
-            }
             return false;
         };
     }
@@ -165,6 +161,24 @@ class DataloaderUtils {
      */
     static getColBatchLoadFn(em) {
         return async (collsWithOpts) => {
+            const prop = collsWithOpts[0][0].property;
+            if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable()) {
+                const options = {};
+                const wrap = (cond) => ({ [prop.name]: cond });
+                const orderBy = Utils_1.Utils.asArray(collsWithOpts[0][1]?.orderBy).map(o => wrap(o));
+                const populate = wrap(collsWithOpts[0][1]?.populate);
+                const owners = collsWithOpts.map(c => c[0].owner);
+                const $or = [];
+                // a bit of a hack, but we need to prefix the key, since we have only a column name, not a property name
+                const alias = em.config.getNamingStrategy().aliasName(prop.pivotEntity, 0);
+                const fk = `${alias}.${Utils_1.Utils.getPrimaryKeyHash(prop.joinColumns)}`;
+                for (const c of collsWithOpts) {
+                    $or.push({ $and: [c[1]?.where ?? {}, { [fk]: c[0].owner }] });
+                    options.refresh ??= c[1]?.refresh;
+                }
+                options.where = wrap({ $or });
+                return em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, collsWithOpts[0][1]?.ref);
+            }
             const entitiesAndOptsMap = DataloaderUtils.groupInversedOrMappedKeysByEntityAndOpts(collsWithOpts);
             const promises = DataloaderUtils.entitiesAndOptsMapToQueries(entitiesAndOptsMap, em);
             const resultsMap = new Map(await Promise.all(promises));