@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/utils/DataloaderUtils.js

@@ -3,6 +3,7 @@ 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.
@@ -10,7 +11,7 @@ export class DataloaderUtils {
     static groupPrimaryKeysByEntityAndOpts(refsWithOpts) {
         const map = new Map();
         for (const [ref, opts] of refsWithOpts) {
-            /* The key is a combination of the className and a stringified version if the load options because we want
+            /* The key is a combination of the uniqueName (a unique table name based identifier) and a stringified version if the load options because we want
                to map each combination of entities/options into separate find queries in order to return accurate results.
                This could be further optimized finding the "lowest common denominator" among the different options
                for each Entity and firing a single query for each Entity instead of Entity+options combination.
@@ -23,7 +24,7 @@ export 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 = `${helper(ref).__meta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${helper(ref).__meta.uniqueName}|${JSON.stringify(opts ?? {})}`;
             let primaryKeysSet = map.get(key);
             if (primaryKeysSet == null) {
                 primaryKeysSet = new Set();
@@ -41,9 +42,10 @@ export class DataloaderUtils {
         return async (refsWithOpts) => {
             const groupedIdsMap = DataloaderUtils.groupPrimaryKeysByEntityAndOpts(refsWithOpts);
             const promises = Array.from(groupedIdsMap).map(([key, idsSet]) => {
-                const className = key.substring(0, key.indexOf('|'));
+                const uniqueName = key.substring(0, key.indexOf('|'));
                 const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
-                return em.find(className, Array.from(idsSet), opts);
+                const meta = em.getMetadata().getByUniqueName(uniqueName);
+                return em.find(meta.class, Array.from(idsSet), opts);
             });
             await Promise.all(promises);
             /* Instead of assigning each find result to the original reference we use a shortcut
@@ -69,7 +71,7 @@ export class DataloaderUtils {
             The value is another Map which we can use to filter the find query to get results pertaining to the collections that have been dataloaded:
             its keys are the props we are going to filter to and its values are the corresponding PKs.
             */
-            const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+            const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
             let filterMap = entitiesMap.get(key); // We are going to use this map to filter the entities pertaining to the collections that have been dataloaded.
             if (filterMap == null) {
                 filterMap = new Map();
@@ -96,31 +98,33 @@ export class DataloaderUtils {
      */
     static entitiesAndOptsMapToQueries(entitiesAndOptsMap, em) {
         return Array.from(entitiesAndOptsMap, async ([key, filterMap]) => {
-            const className = key.substring(0, key.indexOf('|'));
+            const uniqueName = key.substring(0, key.indexOf('|'));
             const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
-            const res = await em.find(className, opts?.where != null && Object.keys(opts.where).length > 0 ?
-                {
+            const meta = em.getMetadata().getByUniqueName(uniqueName);
+            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0
+                ? {
                     $and: [
                         {
                             $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                                return ({ [prop]: Array.from(pks) });
+                                return { [prop]: Array.from(pks) };
                             }),
                         },
                         opts.where,
                     ],
-                } : {
-                // The entries of the filter Map will be used as the values of the $or operator
-                $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                    return ({ [prop]: Array.from(pks) });
-                }),
-            }, {
+                }
+                : {
+                    // The entries of the filter Map will be used as the values of the $or operator
+                    $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
+                        return { [prop]: Array.from(pks) };
+                    }),
+                }, {
                 ...opts,
                 // 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.populate === false ? [] : (opts.populate ?? [])),
                     ...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),
+                    prop => meta.properties[prop]?.ref !== true),
                 ],
             });
             return [key, res];
@@ -163,11 +167,11 @@ export class DataloaderUtils {
             // We need to filter the results in order to map each input collection
             // to a subset of each query matching the collection items.
             return collsWithOpts.map(([col, opts]) => {
-                const key = `${col.property.targetMeta.className}|${JSON.stringify(opts ?? {})}`;
+                const key = `${col.property.targetMeta.uniqueName}|${JSON.stringify(opts ?? {})}`;
                 const entities = resultsMap.get(key);
                 if (entities == null) {
                     // Should never happen
-                    /* v8 ignore next 3 */
+                    /* v8 ignore next */
                     throw new Error('Cannot match results');
                 }
                 return entities.filter(DataloaderUtils.getColFilter(col));
@@ -182,7 +186,7 @@ export class DataloaderUtils {
         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 key = `${col.property.targetMeta.uniqueName}.${col.property.name}|${JSON.stringify(opts ?? {})}`;
                 const value = groups.get(key) ?? [];
                 value.push([col, opts ?? {}]);
                 groups.set(key, value);
@@ -197,17 +201,33 @@ export class DataloaderUtils {
                 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 alias = em.config.getNamingStrategy().aliasName(Utils.className(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);
+                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.");
+        }
+    }
 }

package/utils/EntityComparator.d.ts

@@ -1,54 +1,49 @@
-import type { EntityData, EntityDictionary, EntityMetadata, EntityProperty, IMetadataStorage } from '../typings.js';
+import type { EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
+import type { Configuration } from './Configuration.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 PkGetter<T> = (entity: T) => Primary<T>;
+type PkSerializer<T> = (entity: T) => string;
 type CompositeKeyPart = string | CompositeKeyPart[];
 export declare class EntityComparator {
-    private readonly metadata;
-    private readonly platform;
-    private readonly comparators;
-    private readonly mappers;
-    private readonly snapshotGenerators;
-    private readonly pkGetters;
-    private readonly pkGettersConverted;
-    private readonly pkSerializers;
-    private tmpIndex;
-    constructor(metadata: IMetadataStorage, platform: Platform);
+    #private;
+    constructor(metadata: IMetadataStorage, platform: Platform, config?: Configuration);
     /**
      * Computes difference between two entities.
      */
-    diffEntities<T>(entityName: string, a: EntityData<T>, b: EntityData<T>, options?: {
+    diffEntities<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>, options?: {
         includeInverseSides?: boolean;
     }): EntityData<T>;
-    matching<T>(entityName: string, a: EntityData<T>, b: EntityData<T>): boolean;
+    matching<T extends object>(entityName: EntityName<T>, a: EntityData<T>, b: EntityData<T>): boolean;
     /**
      * Removes ORM specific code from entities and prepares it for serializing. Used before change set computation.
      * References will be mapped to primary keys, collections to arrays of primary keys.
      */
-    prepareEntity<T>(entity: T): EntityData<T>;
+    prepareEntity<T extends object>(entity: T): EntityData<T>;
     /**
      * Maps database columns to properties.
      */
-    mapResult<T>(entityName: string, result: EntityDictionary<T>): EntityData<T>;
+    mapResult<T>(meta: EntityMetadata<T>, result: EntityDictionary<T>): EntityData<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getPkGetter<T>(meta: EntityMetadata<T>): any;
+    getPkGetter<T>(meta: EntityMetadata<T>): PkGetter<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getPkGetterConverted<T>(meta: EntityMetadata<T>): any;
+    getPkGetterConverted<T>(meta: EntityMetadata<T>): PkGetter<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getPkSerializer<T>(meta: EntityMetadata<T>): any;
+    getPkSerializer<T>(meta: EntityMetadata<T>): PkSerializer<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getSnapshotGenerator<T>(entityName: string): SnapshotGenerator<T>;
+    getSnapshotGenerator<T>(entityName: EntityName<T>): SnapshotGenerator<T>;
     /**
      * @internal
      */
@@ -64,7 +59,7 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getResultMapper<T>(entityName: string): ResultMapper<T>;
+    getResultMapper<T>(meta: EntityMetadata<T>): ResultMapper<T>;
     private getPropertyCondition;
     private getEmbeddedArrayPropertySnapshot;
     /**
@@ -78,11 +73,16 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getEntityComparator<T extends object>(entityName: string): Comparator<T>;
+    getEntityComparator<T extends object>(entityName: EntityName<T>): Comparator<T>;
     private getGenericComparator;
     private getPropertyComparator;
     private wrap;
     private safeKey;
+    /**
+     * Sets the toArray helper in the context if not already set.
+     * Used for converting composite PKs to arrays.
+     */
+    private setToArrayHelper;
     /**
      * perf: used to generate list of comparable properties during discovery, so we speed up the runtime comparison
      */