@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/utils/DataloaderUtils.js

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataloaderUtils = void 0;
-const Collection_1 = require("../entity/Collection");
-const wrap_1 = require("../entity/wrap");
-const enums_1 = require("../enums");
-const Reference_1 = require("../entity/Reference");
-class DataloaderUtils {
+import { Collection } from '../entity/Collection.js';
+import { helper } from '../entity/wrap.js';
+import { Reference } from '../entity/Reference.js';
+import { Utils } from './Utils.js';
+export class DataloaderUtils {
+    static DataLoader;
     /**
      * Groups identified references by entity and returns a Map with the
      * class name as the index and the corresponding primary keys as the value.
@@ -26,13 +24,13 @@ class DataloaderUtils {
                Thus such approach should probably be configurable, if not opt-in.
                NOTE: meta + opts multi maps (https://github.com/martian17/ds-js) might be a more elegant way
                to implement this but not necessarily faster.  */
-            const key = `${(0, wrap_1.helper)(ref).__meta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${helper(ref).__meta.className}|${JSON.stringify(opts ?? {})}`;
             let primaryKeysSet = map.get(key);
             if (primaryKeysSet == null) {
                 primaryKeysSet = new Set();
                 map.set(key, primaryKeysSet);
             }
-            primaryKeysSet.add((0, wrap_1.helper)(ref).getPrimaryKey());
+            primaryKeysSet.add(helper(ref).getPrimaryKey());
         }
         return map;
     }
@@ -87,7 +85,7 @@ class DataloaderUtils {
                 filterMap.set(inversedProp, primaryKeys);
             }
             // This is the PK that in conjunction with the filter Map key (the prop) will lead to this specific Collection
-            primaryKeys.add((0, wrap_1.helper)(col.owner).getPrimaryKey());
+            primaryKeys.add(helper(col.owner).getPrimaryKey());
         }
         return entitiesMap;
     }
@@ -121,7 +119,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),
@@ -141,8 +138,8 @@ class DataloaderUtils {
             // This is the inverse side of the relationship where the filtering will be done in order to match the target collection
             // Either inversedBy or mappedBy exist because we already checked in groupInversedOrMappedKeysByEntity
             const inverseProp = collection.property.inversedBy ?? collection.property.mappedBy;
-            const target = Reference_1.Reference.unwrapReference(result[inverseProp]);
-            if (target instanceof Collection_1.Collection) {
+            const target = Reference.unwrapReference(result[inverseProp]);
+            if (target instanceof Collection) {
                 for (const item of target) {
                     if (item === collection.owner) {
                         return true;
@@ -152,15 +149,11 @@ 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;
         };
     }
     /**
-     * Returns the collection dataloader batchLoadFn, which aggregates collections by entity,
+     * Returns the 1:M collection dataloader batchLoadFn, which aggregates collections by entity,
      * makes one query per entity and maps each input collection to the corresponding result.
      */
     static getColBatchLoadFn(em) {
@@ -175,12 +168,61 @@ class DataloaderUtils {
                 const entities = resultsMap.get(key);
                 if (entities == null) {
                     // Should never happen
-                    /* istanbul ignore next */
+                    /* v8 ignore next */
                     throw new Error('Cannot match results');
                 }
                 return entities.filter(DataloaderUtils.getColFilter(col));
             });
         };
     }
+    /**
+     * Returns the M:N collection dataloader batchLoadFn, which aggregates collections by entity,
+     * makes one query per entity and maps each input collection to the corresponding result.
+     */
+    static getManyToManyColBatchLoadFn(em) {
+        return async (collsWithOpts) => {
+            const groups = new Map();
+            for (const [col, opts] of collsWithOpts) {
+                const key = `${col.property.targetMeta.className}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
+                const value = groups.get(key) ?? [];
+                value.push([col, opts ?? {}]);
+                groups.set(key, value);
+            }
+            const ret = [];
+            for (const group of groups.values()) {
+                const prop = group[0][0].property;
+                const options = {};
+                const wrap = (cond) => ({ [prop.name]: cond });
+                const orderBy = Utils.asArray(group[0][1]?.orderBy).map(o => wrap(o));
+                const populate = wrap(group[0][1]?.populate);
+                const owners = group.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.getPrimaryKeyHash(prop.joinColumns)}`;
+                for (const c of group) {
+                    $or.push({ $and: [c[1]?.where ?? {}, { [fk]: c[0].owner }] });
+                    options.refresh ??= c[1]?.refresh;
+                }
+                options.where = wrap({ $or });
+                const r = await em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
+                ret.push(...r);
+            }
+            return ret;
+        };
+    }
+    static async getDataLoader() {
+        if (this.DataLoader) {
+            return this.DataLoader;
+        }
+        try {
+            const mod = await import('dataloader');
+            const DataLoader = mod.default;
+            return (this.DataLoader ??= DataLoader);
+        }
+        catch {
+            /* v8 ignore next */
+            throw new Error('DataLoader is not found, make sure `dataloader` package is installed in your project\'s dependencies.');
+        }
+    }
 }
-exports.DataloaderUtils = DataloaderUtils;

package/utils/EntityComparator.d.ts

@@ -1,6 +1,8 @@
-import type { EntityData, EntityDictionary, EntityMetadata, EntityProperty, IMetadataStorage } from '../typings';
-import type { Platform } from '../platforms';
-type Comparator<T> = (a: T, b: T) => EntityData<T>;
+import type { EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, IMetadataStorage } from '../typings.js';
+import type { Platform } from '../platforms/Platform.js';
+type Comparator<T> = (a: T, b: T, options?: {
+    includeInverseSides?: boolean;
+}) => EntityData<T>;
 type ResultMapper<T> = (result: EntityData<T>) => EntityData<T> | null;
 type SnapshotGenerator<T> = (entity: T) => EntityData<T>;
 type CompositeKeyPart = string | CompositeKeyPart[];
@@ -18,7 +20,9 @@ export declare class EntityComparator {
     /**
      * Computes difference between two entities.
      */
-    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): EntityData<T>;
+    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>, options?: {
+        includeInverseSides?: boolean;
+    }): EntityData<T>;
     matching<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): boolean;
     /**
      * Removes ORM specific code from entities and prepares it for serializing. Used before change set computation.
@@ -44,7 +48,7 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getSnapshotGenerator<T>(entityName: string): SnapshotGenerator<T>;
+    getSnapshotGenerator<T>(entityName: EntityName<T>): SnapshotGenerator<T>;
     /**
      * @internal
      */