@mikro-orm/nestjs 4.3.1 → 5.0.2

package/README.md

@@ -176,8 +176,33 @@ export class MyService {
 }
 ```
 
+## Serialization caveat
+
+[NestJS built-in serialization](https://docs.nestjs.com/techniques/serialization) relies on [class-transformer](https://github.com/typestack/class-transformer). Since MikroORM wraps every single entity relation in a `Reference` or a `Collection` instance (for type-safety), this will make the built-in `ClassSerializerInterceptor` blind to any wrapped relations. In other words, if you return MikroORM entities from your HTTP or WebSocket handlers, all of their relations will NOT be serialized.
+
+Luckily, MikroORM provides a [serialization API](https://mikro-orm.io/docs/serializing) which can be used in lieu of `ClassSerializerInterceptor`.
+
+```typescript
+@Entity()
+export class Book {
+
+  @Property({ hidden: true })   // --> Equivalent of class-transformer's `@Exclude`
+  hiddenField: number = Date.now();
+  
+  @Property({ persist: false }) // --> Will only exist in memory (and will be serialized). Similar to class-transformer's `@Expose()`
+  count?: number;
+  
+  @ManyToOne({ serializer: value => value.name, serializedName: 'authorName' })   // Equivalent of class-transformer's `@Transform()`
+  author: Author;
+
+}
+
+```
+
 ## 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 +233,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 +292,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 +304,6 @@ export class Author {
 `**./author.repository.ts**`
 
 ```ts
-@Repository(Author)
 export class AuthorRepository extends EntityRepository<Author> {
 
   // your custom methods...
@@ -317,6 +340,73 @@ async function bootstrap() {
 
 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,31 +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`');
-            }
-            let result;
-            await core_1.RequestContext.createAsync(context.orm.em, async () => {
-                result = await originalMethod.apply(context, args);
-            });
-            return result;
-        };
-        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,86 +1,96 @@
 "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,
-            useFactory: options.useFactory,
+            useFactory: (...args) => {
+                const factoryOptions = options.useFactory(...args);
+                return options.contextName
+                    ? { contextName: options.contextName, ...factoryOptions }
+                    : factoryOptions;
+            },
             inject: options.inject || [],
         };
     }
     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(),
+        useFactory: async (optionsFactory) => await optionsFactory.createMikroOrmOptions(options.contextName),
         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.1",
+  "version": "5.0.2",
   "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||^5.0.0-dev.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/knex": "^5.0.3",
+    "@mikro-orm/mongodb": "^5.0.3",
+    "@mikro-orm/sqlite": "^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": "^28.0.0",
+    "@types/node": "^17.0.17",
+    "@types/supertest": "^2.0.11",
+    "@typescript-eslint/eslint-plugin": "~5.26.0",
+    "@typescript-eslint/parser": "~5.26.0",
+    "conventional-changelog": "^3.1.25",
+    "conventional-changelog-cli": "^2.2.2",
+    "eslint": "^8.9.0",
+    "jest": "^28.0.0",
+    "rxjs": "^7.5.4",
+    "supertest": "^6.2.2",
+    "ts-jest": "^28.0.0",
+    "ts-node": "^10.5.0",
+    "typescript": "4.6.4"
   },
   "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>;
+    createMikroOrmOptions(contextName?: string): 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 {};