@mikro-orm/core 7.0.0-dev.57 → 7.0.0-dev.59

package/EntityManager.d.ts

@@ -1,5 +1,4 @@
 import { inspect } from 'node:util';
-import DataLoader from 'dataloader';
 import { type Configuration } from './utils/Configuration.js';
 import { Cursor } from './utils/Cursor.js';
 import { EntityFactory } from './entity/EntityFactory.js';
@@ -33,9 +32,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     readonly _id: number;
     readonly global = false;
     readonly name: string;
-    protected readonly refLoader: DataLoader<[Reference<any>, (Omit<import("./entity/Reference.js").LoadReferenceOptions<any, any, "*", never>, "dataloader"> | undefined)?], any, [Reference<any>, (Omit<import("./entity/Reference.js").LoadReferenceOptions<any, any, "*", never>, "dataloader"> | undefined)?]>;
-    protected readonly colLoader: DataLoader<[import("./index.js").Collection<any, object>, (Omit<import("./index.js").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?], any, [import("./index.js").Collection<any, object>, (Omit<import("./index.js").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?]>;
-    protected readonly colLoaderMtoN: DataLoader<[import("./index.js").Collection<any, object>, (Omit<import("./index.js").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?], any, [import("./index.js").Collection<any, object>, (Omit<import("./index.js").InitCollectionOptions<any, any, "*", never>, "dataloader"> | undefined)?]>;
+    private readonly loaders;
     private readonly validator;
     private readonly repositoryMap;
     private readonly entityLoader;
@@ -565,6 +562,8 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * if executed inside request context handler.
      */
     set schema(schema: string | null | undefined);
+    /** @internal */
+    getDataLoader(type: 'ref' | '1:m' | 'm:n'): Promise<any>;
     /**
      * Returns the ID of this EntityManager. Respects the context, so global EM will give you the contextual ID
      * if executed inside request context handler.

package/EntityManager.js

@@ -1,5 +1,4 @@
 import { inspect } from 'node:util';
-import DataLoader from 'dataloader';
 import { getOnConflictReturningFields, getWhereCondition } from './utils/upsert-utils.js';
 import { Utils } from './utils/Utils.js';
 import { Cursor } from './utils/Cursor.js';
@@ -36,9 +35,7 @@ export class EntityManager {
     _id = EntityManager.counter++;
     global = false;
     name;
-    refLoader = new DataLoader(DataloaderUtils.getRefBatchLoadFn(this));
-    colLoader = new DataLoader(DataloaderUtils.getColBatchLoadFn(this));
-    colLoaderMtoN = new DataLoader(DataloaderUtils.getManyToManyColBatchLoadFn(this));
+    loaders = {};
     validator;
     repositoryMap = {};
     entityLoader;
@@ -1854,6 +1851,19 @@ export class EntityManager {
     set schema(schema) {
         this.getContext(false)._schema = schema ?? undefined;
     }
+    /** @internal */
+    async getDataLoader(type) {
+        const em = this.getContext();
+        if (em.loaders[type]) {
+            return em.loaders[type];
+        }
+        const DataLoader = await DataloaderUtils.getDataLoader();
+        switch (type) {
+            case 'ref': return (em.loaders[type] ??= new DataLoader(DataloaderUtils.getRefBatchLoadFn(em)));
+            case '1:m': return (em.loaders[type] ??= new DataLoader(DataloaderUtils.getColBatchLoadFn(em)));
+            case 'm:n': return (em.loaders[type] ??= new DataLoader(DataloaderUtils.getManyToManyColBatchLoadFn(em)));
+        }
+    }
     /**
      * Returns the ID of this EntityManager. Respects the context, so global EM will give you the contextual ID
      * if executed inside request context handler.

package/entity/Collection.js

@@ -228,11 +228,8 @@ export class Collection extends ArrayCollection {
             const orderBy = this.createOrderBy(options.orderBy);
             const customOrder = orderBy.length > 0;
             const pivotTable = this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable();
-            const loader = pivotTable ? 'colLoaderMtoN' : 'colLoader';
-            const items = await em[loader].load([
-                this,
-                { ...options, orderBy },
-            ]);
+            const loader = await em.getDataLoader(pivotTable ? 'm:n' : '1:m');
+            const items = await loader.load([this, { ...options, orderBy }]);
             if (this.property.kind === ReferenceKind.MANY_TO_MANY) {
                 this.initialized = true;
                 this.dirty = false;

package/entity/Reference.js

@@ -94,8 +94,8 @@ export class Reference {
         }
         if (!this.isInitialized() || options.refresh) {
             if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.REFERENCE].includes(wrapped.__em.config.getDataloaderType())) {
-                // eslint-disable-next-line dot-notation
-                return wrapped.__em['refLoader'].load([this, options]);
+                const dataLoader = await wrapped.__em.getDataLoader('ref');
+                return dataLoader.load([this, options]);
             }
             return wrapped.init(options);
         }

package/metadata/MetadataDiscovery.js

@@ -165,7 +165,7 @@ export class MetadataDiscovery {
                 if (this.config.get('discovery').requireEntitiesArray) {
                     throw new Error(`[requireEntitiesArray] Explicit list of entities is required, please use the 'entities' option.`);
                 }
-                const { discoverEntities } = await Utils.dynamicImport('@mikro-orm/core/file-discovery');
+                const { discoverEntities } = await import('@mikro-orm/core/file-discovery' + '');
                 processed.push(...await discoverEntities(entity, { baseDir }));
             }
             else {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.57",
+  "version": "7.0.0-dev.59",
   "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.",
   "exports": {
     "./package.json": "./package.json",
@@ -52,11 +52,18 @@
     "access": "public"
   },
   "dependencies": {
-    "dataloader": "2.2.3",
     "dotenv": "17.2.3",
     "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.57",
+    "mikro-orm": "7.0.0-dev.59",
     "reflect-metadata": "0.2.2",
     "tinyglobby": "0.2.13"
+  },
+  "peerDependencies": {
+    "dataloader": "2.2.3"
+  },
+  "peerDependenciesMeta": {
+    "dataloader": {
+      "optional": true
+    }
   }
 }

package/utils/Configuration.d.ts

@@ -1,8 +1,8 @@
 import type { NamingStrategy } from '../naming-strategy/NamingStrategy.js';
 import { FileCacheAdapter } from '../cache/FileCacheAdapter.js';
-import { type SyncCacheAdapter, type CacheAdapter } from '../cache/CacheAdapter.js';
+import { type CacheAdapter, type SyncCacheAdapter } from '../cache/CacheAdapter.js';
 import type { EntityRepository } from '../entity/EntityRepository.js';
-import type { AnyEntity, Constructor, Dictionary, EntityClass, FilterDef, Highlighter, HydratorConstructor, IHydrator, IMigrationGenerator, IPrimaryKey, MaybePromise, MigrationObject, EntityMetadata, EnsureDatabaseOptions, GenerateOptions, Migration } from '../typings.js';
+import type { AnyEntity, Constructor, Dictionary, EnsureDatabaseOptions, EntityClass, EntityMetadata, FilterDef, GenerateOptions, Highlighter, HydratorConstructor, IHydrator, IMigrationGenerator, IPrimaryKey, MaybePromise, Migration, MigrationObject } from '../typings.js';
 import { ObjectHydrator } from '../hydration/ObjectHydrator.js';
 import { NullHighlighter } from '../utils/NullHighlighter.js';
 import { type Logger, type LoggerNamespace, type LoggerOptions } from '../logging/Logger.js';

package/utils/Configuration.js

@@ -289,8 +289,7 @@ export class Configuration {
      */
     getCachedService(cls, ...args) {
         if (!this.cache.has(cls.name)) {
-            const Class = cls;
-            this.cache.set(cls.name, new Class(...args));
+            this.cache.set(cls.name, new cls(...args));
         }
         return this.cache.get(cls.name);
     }

package/utils/DataloaderUtils.d.ts

@@ -1,9 +1,10 @@
-import type DataLoader from 'dataloader';
-import type { Primary, Ref } from '../typings.js';
+import type { Constructor, Primary, Ref } from '../typings.js';
 import { Collection, type InitCollectionOptions } from '../entity/Collection.js';
 import { type EntityManager } from '../EntityManager.js';
 import { type LoadReferenceOptions } from '../entity/Reference.js';
+type BatchLoadFn<K, V> = (keys: readonly K[]) => PromiseLike<ArrayLike<V | Error>>;
 export declare class DataloaderUtils {
+    private 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.
@@ -13,7 +14,7 @@ export declare class DataloaderUtils {
      * Returns the reference dataloader batchLoadFn, which aggregates references by entity,
      * makes one query per entity and maps each input reference to the corresponding result.
      */
-    static getRefBatchLoadFn(em: EntityManager): DataLoader.BatchLoadFn<[Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?], any>;
+    static getRefBatchLoadFn(em: EntityManager): BatchLoadFn<[Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?], any>;
     /**
      * Groups collections by entity and returns a Map whose keys are the entity names and whose values are filter Maps
      * which we can use to narrow down the find query to return just the items of the collections that have been dataloaded.
@@ -37,10 +38,14 @@ export declare class DataloaderUtils {
      * 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: EntityManager): DataLoader.BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    static getColBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
     /**
      * 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: EntityManager): DataLoader.BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    static getManyToManyColBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    static getDataLoader(): Promise<Constructor<{
+        load: (...args: unknown[]) => Promise<unknown>;
+    }>>;
 }
+export {};

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.
@@ -210,4 +211,18 @@ export class DataloaderUtils {
             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 2 */
+            throw new Error('DataLoader is not found, make sure `dataloader` package is installed in your project\'s dependencies.');
+        }
+    }
 }