@mikro-orm/nestjs 4.3.0 → 5.0.1

package/README.md

@@ -178,6 +178,8 @@ export class MyService {
 
 ## Using `AsyncLocalStorage` for request context
 
+> Since v5 AsyncLocalStorage is used inside RequestContext helper so this section is no longer valid.
+
 By default, the `domain` api is used in the `RequestContext` helper. Since `@mikro-orm/core@4.0.3`,
 you can use the new `AsyncLocalStorage` too, if you are on up to date node version:
 
@@ -208,8 +210,7 @@ app.use((req, res, next) => {
 
 ## Using NestJS `Injection Scopes` for request context
 
-By default, the `domain` api is used in the `RequestContext` helper. Since `@nestjs/common@6`,
-you can use the new `Injection Scopes` (https://docs.nestjs.com/fundamentals/injection-scopes) too:
+Since `@nestjs/common@6`, you can use the new `Injection Scopes` (https://docs.nestjs.com/fundamentals/injection-scopes) too:
 
 ```typescript
 import { Scope } from '@nestjs/common';
@@ -268,7 +269,7 @@ the Nest.js DI container.
 `**./author.entity.ts**`
 
 ```ts
-@Entity()
+@Entity({ customRepository: () => AuthorRepository })
 export class Author {
 
   // to allow inference in `em.getRepository()`
@@ -280,7 +281,6 @@ export class Author {
 `**./author.repository.ts**`
 
 ```ts
-@Repository(Author)
 export class AuthorRepository extends EntityRepository<Author> {
 
   // your custom methods...
@@ -300,6 +300,90 @@ export class MyService {
 }
 ```
 
+## App shutdown and cleanup
+
+By default, NestJS does not listen for system process termination signals (for example SIGTERM). Because of this, the MikroORM shutdown logic will never executed if the process is terminated, which could lead to database connections remaining open and consuming resources. To enable this, the `enableShutdownHooks` function needs to be called when starting up the application.
+
+```ts
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  // Starts listening for shutdown hooks
+  app.enableShutdownHooks();
+
+  await app.listen(3000);
+}
+```
+
+More information about [enableShutdownHooks](https://docs.nestjs.com/fundamentals/lifecycle-events#application-shutdown)
+
+## Multiple Database Connections
+
+You can define multiple database connections by registering multiple `MikroOrmModule` and setting their `contextName`. If you want to use middleware request context you must disable automatic middleware and register `MikroOrmModule` with `forMiddleware()` or use NestJS `Injection Scope`
+
+```typescript
+@Module({
+  imports: [
+    MikroOrmModule.forRoot({
+      contextName: 'db1',
+      registerRequestContext: false, // disable automatatic middleware
+      ...
+    }),
+    MikroOrmModule.forRoot({
+      contextName: 'db2',
+      registerRequestContext: false, // disable automatatic middleware
+      ...
+    }),
+    MikroOrmModule.forMiddleware()
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+```
+
+To access different `MikroORM`/`EntityManager` connections you have to use the new injection tokens `@InjectMikroORM()`/`@InjectEntityManager()` where you are required to pass the `contextName` in:
+
+```ts
+@Injectable()
+export class MyService {
+
+  constructor(@InjectMikroORM('db1') private readonly orm1: MikroORM,
+              @InjectMikroORM('db2') private readonly orm2: MikroORM,
+              @InjectEntityManager('db1') private readonly em1: EntityManager,
+              @InjectEntityManager('db2') private readonly em2: EntityManager) { }
+
+}
+```
+
+When defining your repositories with `forFeature()` method you will need to set which `contextName` you want it registered against:
+
+```typescript
+// photo.module.ts
+
+@Module({
+  imports: [MikroOrmModule.forFeature([Photo], 'db1')],
+  providers: [PhotoService],
+  controllers: [PhotoController],
+})
+export class PhotoModule {}
+```
+
+When using the `@InjectRepository` decorator you will also need to pass the `contextName` you want to get it from:
+
+```typescript
+@Injectable()
+export class PhotoService {
+  constructor(
+    @InjectRepository(Photo, 'db1')
+    private readonly photoRepository: EntityRepository<Photo>
+  ) {}
+
+  // ...
+
+}
+```
+
 ## Testing
 
 The `nestjs-mikro-orm` package exposes `getRepositoryToken()` function that returns prepared token based on a given entity to allow mocking the repository.

package/index.d.ts

@@ -1,4 +1,5 @@
 export * from './mikro-orm.module';
 export * from './mikro-orm.common';
 export * from './mikro-orm.middleware';
+export * from './multiple-mikro-orm.middleware';
 export * from './typings';

package/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -13,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./mikro-orm.module"), exports);
 __exportStar(require("./mikro-orm.common"), exports);
 __exportStar(require("./mikro-orm.middleware"), exports);
+__exportStar(require("./multiple-mikro-orm.middleware"), exports);
 __exportStar(require("./typings"), exports);

package/middleware.helper.d.ts

@@ -0,0 +1,3 @@
+import type { MikroOrmMiddlewareModuleOptions } from './typings';
+import type { MiddlewareConsumer } from '@nestjs/common';
+export declare function forRoutesPath(options: MikroOrmMiddlewareModuleOptions, consumer: MiddlewareConsumer): string;

package/middleware.helper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forRoutesPath = void 0;
+function forRoutesPath(options, consumer) {
+    const isNestMiddleware = (consumer) => {
+        return typeof consumer.httpAdapter === 'object';
+    };
+    const usingFastify = (consumer) => {
+        return consumer.httpAdapter.constructor.name.toLowerCase().startsWith('fastify');
+    };
+    return options.forRoutesPath ??
+        (isNestMiddleware(consumer) && usingFastify(consumer) ? '(.*)' : '*');
+}
+exports.forRoutesPath = forRoutesPath;

package/mikro-orm-core.module.d.ts

@@ -1,6 +1,7 @@
-import { DynamicModule, MiddlewareConsumer, OnApplicationShutdown } from '@nestjs/common';
+import type { DynamicModule, MiddlewareConsumer, OnApplicationShutdown } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import { MikroOrmModuleAsyncOptions, MikroOrmModuleOptions, MikroOrmModuleSyncOptions } from './typings';
+import type { MikroOrmModuleAsyncOptions, MikroOrmModuleSyncOptions } from './typings';
+import { MikroOrmModuleOptions } from './typings';
 export declare class MikroOrmCoreModule implements OnApplicationShutdown {
     private readonly options;
     private readonly moduleRef;
@@ -9,4 +10,5 @@ export declare class MikroOrmCoreModule implements OnApplicationShutdown {
     static forRootAsync(options: MikroOrmModuleAsyncOptions): Promise<DynamicModule>;
     onApplicationShutdown(): Promise<void>;
     configure(consumer: MiddlewareConsumer): void;
+    private static setContextName;
 }

package/mikro-orm-core.module.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -37,22 +41,15 @@ const core_1 = require("@mikro-orm/core");
 const common_1 = require("@nestjs/common");
 const core_2 = require("@nestjs/core");
 const mikro_orm_common_1 = require("./mikro-orm.common");
-const mikro_orm_middleware_1 = require("./mikro-orm.middleware");
 const mikro_orm_providers_1 = require("./mikro-orm.providers");
-var EntityManagerModuleName;
-(function (EntityManagerModuleName) {
-    EntityManagerModuleName["Knex"] = "@mikro-orm/knex";
-    EntityManagerModuleName["MongoDb"] = "@mikro-orm/mongodb";
-})(EntityManagerModuleName || (EntityManagerModuleName = {}));
-async function whenModuleAvailable(moduleName, returnFn) {
+const mikro_orm_middleware_1 = require("./mikro-orm.middleware");
+const middleware_helper_1 = require("./middleware.helper");
+async function tryRequire(cb) {
     try {
-        const module = await Promise.resolve().then(() => __importStar(require(moduleName)));
-        // TReturnValue may be incorrect if expecting it to extend Promise<T> since its being awaited in the return
-        // casting to Awaited<TReturnValue> to satisfy the return type will prevent that confusion
-        return [await returnFn(module)];
+        return await cb();
     }
-    catch (err) {
-        return [];
+    catch {
+        return undefined; // ignore, optional dependency
     }
 }
 let MikroOrmCoreModule = MikroOrmCoreModule_1 = class MikroOrmCoreModule {
@@ -61,70 +58,80 @@ let MikroOrmCoreModule = MikroOrmCoreModule_1 = class MikroOrmCoreModule {
         this.moduleRef = moduleRef;
     }
     static async forRoot(options) {
+        const contextName = this.setContextName(options?.contextName);
+        const knex = await tryRequire(() => Promise.resolve().then(() => __importStar(require('@mikro-orm/knex'))));
+        const mongo = await tryRequire(() => Promise.resolve().then(() => __importStar(require('@mikro-orm/mongodb'))));
         return {
             module: MikroOrmCoreModule_1,
             providers: [
                 { provide: mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS, useValue: options || {} },
-                mikro_orm_providers_1.createMikroOrmProvider(),
-                mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options === null || options === void 0 ? void 0 : options.scope),
-                ...(await whenModuleAvailable(EntityManagerModuleName.Knex, ({ SqlEntityManager }) => mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options === null || options === void 0 ? void 0 : options.scope, SqlEntityManager))),
-                ...(await whenModuleAvailable(EntityManagerModuleName.MongoDb, ({ MongoEntityManager }) => mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options === null || options === void 0 ? void 0 : options.scope, MongoEntityManager))),
+                (0, mikro_orm_providers_1.createMikroOrmProvider)(contextName),
+                (0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, core_1.EntityManager, contextName),
+                ...(knex ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, knex.SqlEntityManager, contextName)] : []),
+                ...(mongo ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, mongo.MongoEntityManager, contextName)] : []),
             ],
             exports: [
-                core_1.MikroORM,
-                core_1.EntityManager,
-                ...(await whenModuleAvailable(EntityManagerModuleName.Knex, ({ SqlEntityManager }) => SqlEntityManager)),
-                ...(await whenModuleAvailable(EntityManagerModuleName.MongoDb, ({ MongoEntityManager }) => MongoEntityManager)),
+                contextName ? (0, mikro_orm_common_1.getMikroORMToken)(contextName) : core_1.MikroORM,
+                contextName ? (0, mikro_orm_common_1.getEntityManagerToken)(contextName) : core_1.EntityManager,
+                ...(knex ? (contextName ? [] : [knex.SqlEntityManager]) : []),
+                ...(mongo ? (contextName ? [] : [mongo.MongoEntityManager]) : []),
             ],
         };
     }
     static async forRootAsync(options) {
+        const contextName = this.setContextName(options?.contextName);
+        const knex = await tryRequire(() => Promise.resolve().then(() => __importStar(require('@mikro-orm/knex'))));
+        const mongo = await tryRequire(() => Promise.resolve().then(() => __importStar(require('@mikro-orm/mongodb'))));
         return {
             module: MikroOrmCoreModule_1,
             imports: options.imports || [],
             providers: [
                 ...(options.providers || []),
-                ...mikro_orm_providers_1.createAsyncProviders(options),
-                mikro_orm_providers_1.createMikroOrmProvider(),
-                mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options.scope),
-                ...(await whenModuleAvailable(EntityManagerModuleName.Knex, ({ SqlEntityManager }) => mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options.scope, SqlEntityManager))),
-                ...(await whenModuleAvailable(EntityManagerModuleName.MongoDb, ({ MongoEntityManager }) => mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options.scope, MongoEntityManager))),
+                ...(0, mikro_orm_providers_1.createAsyncProviders)({ ...options, contextName: options.contextName }),
+                (0, mikro_orm_providers_1.createMikroOrmProvider)(contextName),
+                (0, mikro_orm_providers_1.createEntityManagerProvider)(options.scope, core_1.EntityManager, contextName),
+                ...(knex ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, knex.SqlEntityManager, contextName)] : []),
+                ...(mongo ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, mongo.MongoEntityManager, contextName)] : []),
             ],
             exports: [
-                core_1.MikroORM,
-                core_1.EntityManager,
-                ...(await whenModuleAvailable(EntityManagerModuleName.Knex, ({ SqlEntityManager }) => SqlEntityManager)),
-                ...(await whenModuleAvailable(EntityManagerModuleName.MongoDb, ({ MongoEntityManager }) => MongoEntityManager)),
+                contextName ? (0, mikro_orm_common_1.getMikroORMToken)(contextName) : core_1.MikroORM,
+                contextName ? (0, mikro_orm_common_1.getEntityManagerToken)(contextName) : core_1.EntityManager,
+                ...(knex ? (contextName ? [] : [knex.SqlEntityManager]) : []),
+                ...(mongo ? (contextName ? [] : [mongo.MongoEntityManager]) : []),
             ],
         };
     }
     async onApplicationShutdown() {
-        const orm = this.moduleRef.get(core_1.MikroORM);
+        const token = this.options.contextName ? (0, mikro_orm_common_1.getMikroORMToken)(this.options.contextName) : core_1.MikroORM;
+        const orm = this.moduleRef.get(token);
         if (orm) {
             await orm.close();
         }
+        mikro_orm_common_1.CONTEXT_NAMES.length = 0;
     }
     configure(consumer) {
-        var _a;
         if (this.options.registerRequestContext === false) {
             return;
         }
-        const isNestMiddleware = (consumer) => {
-            return typeof consumer.httpAdapter === 'object';
-        };
-        const usingFastify = (consumer) => {
-            return consumer.httpAdapter.constructor.name.toLowerCase().startsWith('fastify');
-        };
-        const forRoutesPath = (_a = this.options.forRoutesPath) !== null && _a !== void 0 ? _a : (isNestMiddleware(consumer) && usingFastify(consumer) ? '(.*)' : '*');
         consumer
             .apply(mikro_orm_middleware_1.MikroOrmMiddleware) // register request context automatically
-            .forRoutes({ path: forRoutesPath, method: common_1.RequestMethod.ALL });
+            .forRoutes({ path: (0, middleware_helper_1.forRoutesPath)(this.options, consumer), method: common_1.RequestMethod.ALL });
+    }
+    static setContextName(contextName) {
+        if (!contextName) {
+            return;
+        }
+        if (mikro_orm_common_1.CONTEXT_NAMES.includes(contextName)) {
+            throw new Error(`ContextName '${contextName}' already registered`);
+        }
+        mikro_orm_common_1.CONTEXT_NAMES.push(contextName);
+        return contextName;
     }
 };
 MikroOrmCoreModule = MikroOrmCoreModule_1 = __decorate([
-    common_1.Global(),
-    common_1.Module({}),
-    __param(0, common_1.Inject(mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS)),
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __param(0, (0, common_1.Inject)(mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS)),
     __metadata("design:paramtypes", [Object, core_2.ModuleRef])
 ], MikroOrmCoreModule);
 exports.MikroOrmCoreModule = MikroOrmCoreModule;

package/mikro-orm-middleware.module.d.ts

@@ -0,0 +1,22 @@
+import type { MiddlewareConsumer } from '@nestjs/common';
+import { MikroOrmMiddlewareModuleOptions } from './typings';
+import type { MikroORM } from '@mikro-orm/core';
+export declare class MikroOrmMiddlewareModule {
+    private readonly options;
+    constructor(options: MikroOrmMiddlewareModuleOptions);
+    static forMiddleware(options?: MikroOrmMiddlewareModuleOptions): {
+        module: typeof MikroOrmMiddlewareModule;
+        providers: ({
+            provide: symbol;
+            useValue: MikroOrmMiddlewareModuleOptions;
+            useFactory?: undefined;
+            inject?: undefined;
+        } | {
+            provide: string;
+            useFactory: (...args: MikroORM[]) => MikroORM<import("@mikro-orm/core").IDatabaseDriver<import("@mikro-orm/core").Connection>>[];
+            inject: string[];
+            useValue?: undefined;
+        })[];
+    };
+    configure(consumer: MiddlewareConsumer): void;
+}

package/mikro-orm-middleware.module.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var MikroOrmMiddlewareModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MikroOrmMiddlewareModule = void 0;
+const common_1 = require("@nestjs/common");
+const mikro_orm_common_1 = require("./mikro-orm.common");
+const multiple_mikro_orm_middleware_1 = require("./multiple-mikro-orm.middleware");
+const middleware_helper_1 = require("./middleware.helper");
+let MikroOrmMiddlewareModule = MikroOrmMiddlewareModule_1 = class MikroOrmMiddlewareModule {
+    constructor(options) {
+        this.options = options;
+    }
+    static forMiddleware(options) {
+        // Work around due to nestjs not supporting the ability to register multiple types
+        // https://github.com/nestjs/nest/issues/770
+        // https://github.com/nestjs/nest/issues/4786#issuecomment-755032258 - workaround suggestion
+        const inject = mikro_orm_common_1.CONTEXT_NAMES.map(name => (0, mikro_orm_common_1.getMikroORMToken)(name));
+        return {
+            module: MikroOrmMiddlewareModule_1,
+            providers: [
+                { provide: mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS, useValue: options || {} },
+                {
+                    provide: 'MikroORMs',
+                    useFactory: (...args) => args,
+                    inject,
+                },
+            ],
+        };
+    }
+    configure(consumer) {
+        consumer
+            .apply(multiple_mikro_orm_middleware_1.MultipleMikroOrmMiddleware)
+            .forRoutes({ path: (0, middleware_helper_1.forRoutesPath)(this.options, consumer), method: common_1.RequestMethod.ALL });
+    }
+};
+MikroOrmMiddlewareModule = MikroOrmMiddlewareModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __param(0, (0, common_1.Inject)(mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], MikroOrmMiddlewareModule);
+exports.MikroOrmMiddlewareModule = MikroOrmMiddlewareModule;

package/mikro-orm.common.d.ts

@@ -1,8 +1,11 @@
-import { AnyEntity, EntityName } from '@mikro-orm/core';
+import type { EntityName } from '@mikro-orm/core';
 import { Logger } from '@nestjs/common';
 export declare const MIKRO_ORM_MODULE_OPTIONS: unique symbol;
-export declare const REGISTERED_ENTITIES: Set<EntityName<AnyEntity<any>>>;
+export declare const CONTEXT_NAMES: string[];
 export declare const logger: Logger;
-export declare const getRepositoryToken: <T>(entity: EntityName<T>) => string;
-export declare const InjectRepository: <T>(entity: EntityName<T>) => (target: object, key: string | symbol, index?: number | undefined) => void;
-export declare function UseRequestContext(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const getMikroORMToken: (name: string) => string;
+export declare const InjectMikroORM: (name: string) => (target: object, key: string | symbol, index?: number | undefined) => void;
+export declare const getEntityManagerToken: (name: string) => string;
+export declare const InjectEntityManager: (name: string) => (target: object, key: string | symbol, index?: number | undefined) => void;
+export declare const getRepositoryToken: <T>(entity: EntityName<T>, name?: string | undefined) => string;
+export declare const InjectRepository: <T>(entity: EntityName<T>, name?: string | undefined) => (target: object, key: string | symbol, index?: number | undefined) => void;

package/mikro-orm.common.js

@@ -1,29 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UseRequestContext = exports.InjectRepository = exports.getRepositoryToken = exports.logger = exports.REGISTERED_ENTITIES = exports.MIKRO_ORM_MODULE_OPTIONS = void 0;
+exports.InjectRepository = exports.getRepositoryToken = exports.InjectEntityManager = exports.getEntityManagerToken = exports.InjectMikroORM = exports.getMikroORMToken = exports.logger = exports.CONTEXT_NAMES = exports.MIKRO_ORM_MODULE_OPTIONS = void 0;
 const core_1 = require("@mikro-orm/core");
 const common_1 = require("@nestjs/common");
 exports.MIKRO_ORM_MODULE_OPTIONS = Symbol('mikro-orm-module-options');
-exports.REGISTERED_ENTITIES = new Set();
+exports.CONTEXT_NAMES = [];
 exports.logger = new common_1.Logger(core_1.MikroORM.name);
-const getRepositoryToken = (entity) => `${core_1.Utils.className(entity)}Repository`;
+const getMikroORMToken = (name) => `${name}_MikroORM`;
+exports.getMikroORMToken = getMikroORMToken;
+const InjectMikroORM = (name) => (0, common_1.Inject)((0, exports.getMikroORMToken)(name));
+exports.InjectMikroORM = InjectMikroORM;
+const getEntityManagerToken = (name) => `${name}_EntityManager`;
+exports.getEntityManagerToken = getEntityManagerToken;
+const InjectEntityManager = (name) => (0, common_1.Inject)((0, exports.getEntityManagerToken)(name));
+exports.InjectEntityManager = InjectEntityManager;
+const getRepositoryToken = (entity, name) => {
+    const suffix = name ? `_${name}` : '';
+    return `${core_1.Utils.className(entity)}Repository${suffix}`;
+};
 exports.getRepositoryToken = getRepositoryToken;
-const InjectRepository = (entity) => common_1.Inject(exports.getRepositoryToken(entity));
+const InjectRepository = (entity, name) => (0, common_1.Inject)((0, exports.getRepositoryToken)(entity, name));
 exports.InjectRepository = InjectRepository;
-function UseRequestContext() {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            const context = this;
-            if (!(context.orm instanceof core_1.MikroORM)) {
-                throw new Error('@UseRequestContext() decorator can only be applied to methods of classes that carry `orm: MikroORM`');
-            }
-            await core_1.RequestContext.createAsync(context.orm.em, async () => {
-                await originalMethod.apply(context, args);
-            });
-        };
-        return descriptor;
-    };
-}
-exports.UseRequestContext = UseRequestContext;

package/mikro-orm.entities.storage.d.ts

@@ -0,0 +1,7 @@
+import type { AnyEntity, EntityName } from '@mikro-orm/core';
+export declare class MikroOrmEntitiesStorage {
+    private static readonly storage;
+    static addEntity(entity: EntityName<AnyEntity>, contextName?: string): void;
+    static getEntities(contextName?: string): never[] | IterableIterator<EntityName<AnyEntity<any>>>;
+    static clear(contextName?: string): void;
+}

package/mikro-orm.entities.storage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MikroOrmEntitiesStorage = void 0;
+class MikroOrmEntitiesStorage {
+    static addEntity(entity, contextName = 'default') {
+        let set = this.storage.get(contextName);
+        if (!set) {
+            set = new Set();
+            this.storage.set(contextName, set);
+        }
+        set.add(entity);
+    }
+    static getEntities(contextName = 'default') {
+        return this.storage.get(contextName)?.values() || [];
+    }
+    static clear(contextName = 'default') {
+        const set = this.storage.get(contextName);
+        if (!set) {
+            return;
+        }
+        set.clear();
+    }
+}
+exports.MikroOrmEntitiesStorage = MikroOrmEntitiesStorage;
+MikroOrmEntitiesStorage.storage = new Map();

package/mikro-orm.middleware.d.ts

@@ -1,5 +1,5 @@
 import { MikroORM } from '@mikro-orm/core';
-import { NestMiddleware } from '@nestjs/common';
+import type { NestMiddleware } from '@nestjs/common';
 export declare class MikroOrmMiddleware implements NestMiddleware {
     private readonly orm;
     constructor(orm: MikroORM);

package/mikro-orm.middleware.js

@@ -21,7 +21,7 @@ let MikroOrmMiddleware = class MikroOrmMiddleware {
     }
 };
 MikroOrmMiddleware = __decorate([
-    common_1.Injectable(),
+    (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [core_1.MikroORM])
 ], MikroOrmMiddleware);
 exports.MikroOrmMiddleware = MikroOrmMiddleware;

package/mikro-orm.module.d.ts

@@ -1,10 +1,9 @@
-import { AnyEntity, EntityName } from '@mikro-orm/core';
-import { DynamicModule } from '@nestjs/common';
-import { MikroOrmModuleAsyncOptions, MikroOrmModuleSyncOptions } from './typings';
+import type { AnyEntity, EntityName } from '@mikro-orm/core';
+import type { DynamicModule } from '@nestjs/common';
+import type { MikroOrmModuleAsyncOptions, MikroOrmModuleSyncOptions, MikroOrmMiddlewareModuleOptions, MikroOrmModuleFeatureOptions } from './typings';
 export declare class MikroOrmModule {
     static forRoot(options?: MikroOrmModuleSyncOptions): DynamicModule;
     static forRootAsync(options: MikroOrmModuleAsyncOptions): DynamicModule;
-    static forFeature(options: EntityName<AnyEntity>[] | {
-        entities?: EntityName<AnyEntity>[];
-    }): DynamicModule;
+    static forFeature(options: EntityName<AnyEntity>[] | MikroOrmModuleFeatureOptions, contextName?: string): DynamicModule;
+    static forMiddleware(options?: MikroOrmMiddlewareModuleOptions): DynamicModule;
 }

package/mikro-orm.module.js

@@ -12,7 +12,8 @@ const core_1 = require("@mikro-orm/core");
 const common_1 = require("@nestjs/common");
 const mikro_orm_providers_1 = require("./mikro-orm.providers");
 const mikro_orm_core_module_1 = require("./mikro-orm-core.module");
-const mikro_orm_common_1 = require("./mikro-orm.common");
+const mikro_orm_middleware_module_1 = require("./mikro-orm-middleware.module");
+const mikro_orm_entities_storage_1 = require("./mikro-orm.entities.storage");
 let MikroOrmModule = MikroOrmModule_1 = class MikroOrmModule {
     static forRoot(options) {
         return {
@@ -26,12 +27,13 @@ let MikroOrmModule = MikroOrmModule_1 = class MikroOrmModule {
             imports: [mikro_orm_core_module_1.MikroOrmCoreModule.forRootAsync(options)],
         };
     }
-    static forFeature(options) {
+    static forFeature(options, contextName) {
         const entities = Array.isArray(options) ? options : (options.entities || []);
-        const providers = mikro_orm_providers_1.createMikroOrmRepositoryProviders(entities);
+        const name = (Array.isArray(options) || contextName) ? contextName : options.contextName;
+        const providers = (0, mikro_orm_providers_1.createMikroOrmRepositoryProviders)(entities, name);
         for (const e of entities) {
             if (!core_1.Utils.isString(e)) {
-                mikro_orm_common_1.REGISTERED_ENTITIES.add(e);
+                mikro_orm_entities_storage_1.MikroOrmEntitiesStorage.addEntity(e, name);
             }
         }
         return {
@@ -40,8 +42,14 @@ let MikroOrmModule = MikroOrmModule_1 = class MikroOrmModule {
             exports: [...providers],
         };
     }
+    static forMiddleware(options) {
+        return {
+            module: MikroOrmModule_1,
+            imports: [mikro_orm_middleware_module_1.MikroOrmMiddlewareModule.forMiddleware(options)],
+        };
+    }
 };
 MikroOrmModule = MikroOrmModule_1 = __decorate([
-    common_1.Module({})
+    (0, common_1.Module)({})
 ], MikroOrmModule);
 exports.MikroOrmModule = MikroOrmModule;

package/mikro-orm.providers.d.ts

@@ -1,9 +1,10 @@
-import { AnyEntity, EntityManager, EntityName, EntityManagerType, IDatabaseDriver } from '@mikro-orm/core';
-import { MikroOrmModuleAsyncOptions } from './typings';
-import { Provider, Scope, Type } from '@nestjs/common';
-export declare const createMikroOrmProvider: () => Provider;
-export declare type EntityManagerProvider = Provider<IDatabaseDriver[typeof EntityManagerType] & EntityManager>;
-export declare const createMikroOrmEntityManagerProvider: (scope?: Scope, entityManager?: Type<EntityManager>) => EntityManagerProvider;
-export declare const createMikroOrmAsyncOptionsProvider: (options: MikroOrmModuleAsyncOptions) => Provider;
-export declare const createAsyncProviders: (options: MikroOrmModuleAsyncOptions) => Provider[];
-export declare const createMikroOrmRepositoryProviders: (entities: EntityName<AnyEntity>[]) => Provider[];
+import type { AnyEntity, EntityName } from '@mikro-orm/core';
+import { EntityManager } from '@mikro-orm/core';
+import type { MikroOrmModuleAsyncOptions } from './typings';
+import type { Provider, Type } from '@nestjs/common';
+import { Scope } from '@nestjs/common';
+export declare function createMikroOrmProvider(contextName?: string): Provider;
+export declare function createEntityManagerProvider(scope?: Scope, entityManager?: Type, contextName?: string): Provider<EntityManager>;
+export declare function createMikroOrmAsyncOptionsProvider(options: MikroOrmModuleAsyncOptions): Provider;
+export declare function createAsyncProviders(options: MikroOrmModuleAsyncOptions): Provider[];
+export declare function createMikroOrmRepositoryProviders(entities: EntityName<AnyEntity>[], contextName?: string): Provider[];

package/mikro-orm.providers.js

@@ -1,37 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMikroOrmRepositoryProviders = exports.createAsyncProviders = exports.createMikroOrmAsyncOptionsProvider = exports.createMikroOrmEntityManagerProvider = exports.createMikroOrmProvider = void 0;
+exports.createMikroOrmRepositoryProviders = exports.createAsyncProviders = exports.createMikroOrmAsyncOptionsProvider = exports.createEntityManagerProvider = exports.createMikroOrmProvider = void 0;
 const mikro_orm_common_1 = require("./mikro-orm.common");
 const core_1 = require("@mikro-orm/core");
 const common_1 = require("@nestjs/common");
-const createMikroOrmProvider = () => ({
-    provide: core_1.MikroORM,
-    useFactory: async (options) => {
-        if (options === null || options === void 0 ? void 0 : options.autoLoadEntities) {
-            options.entities = [...(options.entities || []), ...mikro_orm_common_1.REGISTERED_ENTITIES.values()];
-            options.entitiesTs = [...(options.entitiesTs || []), ...mikro_orm_common_1.REGISTERED_ENTITIES.values()];
-            delete options.autoLoadEntities;
-        }
-        mikro_orm_common_1.REGISTERED_ENTITIES.clear();
-        if (!options || Object.keys(options).length === 0) {
-            const config = await core_1.ConfigurationLoader.getConfiguration();
-            config.set('logger', mikro_orm_common_1.logger.log.bind(mikro_orm_common_1.logger));
-            options = config;
-        }
-        return core_1.MikroORM.init(options);
-    },
-    inject: [mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS],
-});
+const mikro_orm_entities_storage_1 = require("./mikro-orm.entities.storage");
+function createMikroOrmProvider(contextName) {
+    return {
+        provide: contextName ? (0, mikro_orm_common_1.getMikroORMToken)(contextName) : core_1.MikroORM,
+        useFactory: async (options) => {
+            if (options?.autoLoadEntities) {
+                options.entities = [...(options.entities || []), ...mikro_orm_entities_storage_1.MikroOrmEntitiesStorage.getEntities(contextName)];
+                options.entitiesTs = [...(options.entitiesTs || []), ...mikro_orm_entities_storage_1.MikroOrmEntitiesStorage.getEntities(contextName)];
+                delete options.autoLoadEntities;
+            }
+            mikro_orm_entities_storage_1.MikroOrmEntitiesStorage.clear(contextName);
+            if (!options || Object.keys(options).length === 0) {
+                const config = await core_1.ConfigurationLoader.getConfiguration();
+                config.set('logger', mikro_orm_common_1.logger.log.bind(mikro_orm_common_1.logger));
+                options = config;
+            }
+            return core_1.MikroORM.init(options);
+        },
+        inject: [mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS],
+    };
+}
 exports.createMikroOrmProvider = createMikroOrmProvider;
-const createMikroOrmEntityManagerProvider = (scope = common_1.Scope.DEFAULT, entityManager = core_1.EntityManager) => ({
-    provide: entityManager,
-    scope,
-    useFactory: (orm) => scope === common_1.Scope.DEFAULT ? orm.em : orm.em.fork(),
-    inject: [core_1.MikroORM],
-});
-exports.createMikroOrmEntityManagerProvider = createMikroOrmEntityManagerProvider;
-const createMikroOrmAsyncOptionsProvider = (options) => {
-    var _a;
+function createEntityManagerProvider(scope = common_1.Scope.DEFAULT, entityManager = core_1.EntityManager, contextName) {
+    return {
+        provide: contextName ? (0, mikro_orm_common_1.getEntityManagerToken)(contextName) : entityManager,
+        scope,
+        useFactory: (orm) => scope === common_1.Scope.DEFAULT ? orm.em : orm.em.fork(),
+        inject: [contextName ? (0, mikro_orm_common_1.getMikroORMToken)(contextName) : core_1.MikroORM],
+    };
+}
+exports.createEntityManagerProvider = createEntityManagerProvider;
+function createMikroOrmAsyncOptionsProvider(options) {
     if (options.useFactory) {
         return {
             provide: mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS,
@@ -41,46 +45,47 @@ const createMikroOrmAsyncOptionsProvider = (options) => {
     }
     const inject = [];
     if (options.useClass || options.useExisting) {
-        inject.push((_a = options.useClass) !== null && _a !== void 0 ? _a : options.useExisting);
+        inject.push(options.useClass ?? options.useExisting);
     }
     return {
         provide: mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS,
         useFactory: async (optionsFactory) => await optionsFactory.createMikroOrmOptions(),
         inject,
     };
-};
+}
 exports.createMikroOrmAsyncOptionsProvider = createMikroOrmAsyncOptionsProvider;
-const createAsyncProviders = (options) => {
+function createAsyncProviders(options) {
     if (options.useExisting || options.useFactory) {
-        return [exports.createMikroOrmAsyncOptionsProvider(options)];
+        return [createMikroOrmAsyncOptionsProvider(options)];
     }
     if (options.useClass) {
         return [
-            exports.createMikroOrmAsyncOptionsProvider(options),
+            createMikroOrmAsyncOptionsProvider(options),
             { provide: options.useClass, useClass: options.useClass },
         ];
     }
     throw new Error('Invalid MikroORM async options: one of `useClass`, `useExisting` or `useFactory` should be defined.');
-};
+}
 exports.createAsyncProviders = createAsyncProviders;
-const createMikroOrmRepositoryProviders = (entities) => {
+function createMikroOrmRepositoryProviders(entities, contextName) {
     const metadata = Object.values(core_1.MetadataStorage.getMetadata());
     const providers = [];
+    const inject = contextName ? (0, mikro_orm_common_1.getEntityManagerToken)(contextName) : core_1.EntityManager;
     (entities || []).forEach(entity => {
         const meta = metadata.find(meta => meta.class === entity);
-        if (meta === null || meta === void 0 ? void 0 : meta.customRepository) {
+        if (meta?.customRepository) {
             providers.push({
                 provide: meta.customRepository(),
                 useFactory: em => em.getRepository(entity),
-                inject: [core_1.EntityManager],
+                inject: [inject],
             });
         }
         providers.push({
-            provide: mikro_orm_common_1.getRepositoryToken(entity),
+            provide: (0, mikro_orm_common_1.getRepositoryToken)(entity, contextName),
             useFactory: em => em.getRepository(entity),
-            inject: [core_1.EntityManager],
+            inject: [inject],
         });
     });
     return providers;
-};
+}
 exports.createMikroOrmRepositoryProviders = createMikroOrmRepositoryProviders;

package/multiple-mikro-orm.middleware.d.ts

@@ -0,0 +1,7 @@
+import type { MikroORM } from '@mikro-orm/core';
+import type { NestMiddleware } from '@nestjs/common';
+export declare class MultipleMikroOrmMiddleware implements NestMiddleware {
+    private readonly orm;
+    constructor(orm: MikroORM[]);
+    use(req: unknown, res: unknown, next: (...args: any[]) => void): void;
+}

package/multiple-mikro-orm.middleware.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultipleMikroOrmMiddleware = void 0;
+const core_1 = require("@mikro-orm/core");
+const common_1 = require("@nestjs/common");
+let MultipleMikroOrmMiddleware = class MultipleMikroOrmMiddleware {
+    constructor(orm) {
+        this.orm = orm;
+    }
+    use(req, res, next) {
+        core_1.RequestContext.create(this.orm.map(orm => orm.em), next);
+    }
+};
+MultipleMikroOrmMiddleware = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)('MikroORMs')),
+    __metadata("design:paramtypes", [Array])
+], MultipleMikroOrmMiddleware);
+exports.MultipleMikroOrmMiddleware = MultipleMikroOrmMiddleware;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@mikro-orm/nestjs",
-  "version": "4.3.0",
+  "version": "5.0.1",
   "license": "MIT",
   "author": {
-    "name": "Dario Mancuso",
-    "email": "dario@ewide.eu"
+    "name": "Martin Adamek",
+    "email": "banan23@gmail.com"
   },
   "keywords": [
     "nestjs",
@@ -37,55 +37,52 @@
     "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 1",
     "release": "yarn build && cd dist && npm publish && cd ..",
     "coverage": "yarn test --coverage",
-    "coveralls": "cat ./coverage/lcov.info | coveralls",
     "lint": "eslint src/**/*.ts"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "^4.0.0",
-    "@nestjs/common": "^7.0.0||^8.0.0",
-    "@nestjs/core": "^7.0.0||^8.0.0"
+    "@mikro-orm/core": "^5.0.0",
+    "@mikro-orm/knex": "^5.0.0",
+    "@mikro-orm/mongodb": "^5.0.0",
+    "@nestjs/common": "^8.0.0",
+    "@nestjs/core": "^8.0.0"
   },
-  "devDependencies": {
-    "@mikro-orm/core": "^4.5.7",
-    "@mikro-orm/sqlite": "^4.5.7",
-    "@nestjs/common": "^8.0.6",
-    "@nestjs/core": "^8.0.6",
-    "@nestjs/testing": "^8.0.6",
-    "@types/jest": "^26.0.10",
-    "@typescript-eslint/eslint-plugin": "~3.9.1",
-    "@typescript-eslint/parser": "~3.9.1",
-    "conventional-changelog": "^3.1.23",
-    "conventional-changelog-cli": "^2.1.1",
-    "eslint": "^7.7.0",
-    "eslint-plugin-jsdoc": "^30.2.4",
-    "jest": "^26.4.0",
-    "rxjs": "^6.6.2",
-    "ts-jest": "^26.2.0",
-    "typescript": "4.3.5"
+  "peerDependenciesMeta": {
+    "@mikro-orm/knex": {
+      "optional": true
+    },
+    "@mikro-orm/mongodb": {
+      "optional": true
+    }
   },
-  "jest": {
-    "testTimeout": 30000,
-    "preset": "ts-jest",
-    "collectCoverage": false,
-    "collectCoverageFrom": [
-      "<rootDir>/src/**/*.ts"
-    ],
-    "modulePathIgnorePatterns": [
-      "dist/package.json",
-      "<rootDir>/package.json"
-    ]
+  "devDependencies": {
+    "@mikro-orm/core": "^5.0.3",
+    "@mikro-orm/sqlite": "^5.0.3",
+    "@mikro-orm/mongodb": "^5.0.3",
+    "@mikro-orm/knex": "^5.0.3",
+    "@nestjs/common": "^8.2.6",
+    "@nestjs/core": "^8.2.6",
+    "@nestjs/platform-express": "^8.2.6",
+    "@nestjs/testing": "^8.2.6",
+    "@types/jest": "^27.4.0",
+    "@types/node": "^17.0.17",
+    "@types/supertest": "^2.0.11",
+    "@typescript-eslint/eslint-plugin": "~5.14.0",
+    "@typescript-eslint/parser": "~5.14.0",
+    "conventional-changelog": "^3.1.25",
+    "conventional-changelog-cli": "^2.2.2",
+    "eslint": "^8.9.0",
+    "jest": "^27.5.1",
+    "rxjs": "^7.5.4",
+    "supertest": "^6.2.2",
+    "ts-jest": "^27.1.3",
+    "ts-node": "^10.5.0",
+    "typescript": "4.6.2"
   },
   "commitlint": {
     "extends": [
       "@commitlint/config-conventional"
     ]
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged",
-      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
-    }
-  },
   "lint-staged": {
     "*.ts": [
       "eslint src/**/*.ts --fix"
@@ -93,11 +90,30 @@
   },
   "renovate": {
     "extends": [
-      "config:base"
+      "config:base",
+      ":preserveSemverRanges",
+      ":semanticCommitTypeAll(chore)"
     ],
-    "pinVersions": false
+    "semanticCommits": "enabled",
+    "separateMajorMinor": false,
+    "dependencyDashboard": false,
+    "packageRules": [
+      {
+        "matchUpdateTypes": [
+          "patch",
+          "minor"
+        ],
+        "groupName": "patch/minor dependencies",
+        "groupSlug": "all-non-major",
+        "automerge": true,
+        "automergeType": "branch"
+      }
+    ],
+    "schedule": [
+      "every weekday"
+    ]
   },
   "engines": {
-    "node": ">= 10.13.0"
+    "node": ">= 14.0.0"
   }
 }

package/typings.d.ts

@@ -1,15 +1,13 @@
-import { IDatabaseDriver, Options } from '@mikro-orm/core';
-import { MiddlewareConsumer, ModuleMetadata, Scope, Type } from '@nestjs/common';
-import { AbstractHttpAdapter } from '@nestjs/core';
+import type { AnyEntity, EntityName, IDatabaseDriver, Options } from '@mikro-orm/core';
+import type { MiddlewareConsumer, ModuleMetadata, Scope, Type } from '@nestjs/common';
+import type { AbstractHttpAdapter } from '@nestjs/core';
 export interface NestMiddlewareConsumer extends MiddlewareConsumer {
     httpAdapter: AbstractHttpAdapter;
 }
 declare type MikroOrmNestScopeOptions = {
     scope?: Scope;
 };
-export declare type MikroOrmModuleOptions<D extends IDatabaseDriver = IDatabaseDriver> = {
-    registerRequestContext?: boolean;
-    autoLoadEntities?: boolean;
+export declare type MikroOrmMiddlewareModuleOptions = {
     /**
      * Routes to apply the middleware.
      *
@@ -18,16 +16,25 @@ export declare type MikroOrmModuleOptions<D extends IDatabaseDriver = IDatabaseD
      * For all other frameworks including Express, the middleware applies to all routes using `*`.
      */
     forRoutesPath?: string;
-} & Options<D>;
+};
+export declare type MikroOrmModuleOptions<D extends IDatabaseDriver = IDatabaseDriver> = {
+    registerRequestContext?: boolean;
+    autoLoadEntities?: boolean;
+} & Options<D> & MikroOrmMiddlewareModuleOptions;
+export interface MikroOrmModuleFeatureOptions {
+    entities?: EntityName<AnyEntity>[];
+    contextName?: string;
+}
 export interface MikroOrmOptionsFactory<D extends IDatabaseDriver = IDatabaseDriver> {
     createMikroOrmOptions(): Promise<MikroOrmModuleOptions<D>> | MikroOrmModuleOptions<D>;
 }
 export interface MikroOrmModuleSyncOptions extends MikroOrmModuleOptions, MikroOrmNestScopeOptions {
 }
 export interface MikroOrmModuleAsyncOptions<D extends IDatabaseDriver = IDatabaseDriver> extends Pick<ModuleMetadata, 'imports' | 'providers'>, MikroOrmNestScopeOptions {
+    contextName?: string;
     useExisting?: Type<MikroOrmOptionsFactory<D>>;
     useClass?: Type<MikroOrmOptionsFactory<D>>;
-    useFactory?: (...args: any[]) => Promise<MikroOrmModuleOptions<D>> | MikroOrmModuleOptions<D>;
+    useFactory?: (...args: any[]) => Promise<Omit<MikroOrmModuleOptions<D>, 'contextName'>> | Omit<MikroOrmModuleOptions<D>, 'contextName'>;
     inject?: any[];
 }
 export {};