@mikro-orm/nestjs 6.0.2 → 6.1.1

package/README.md

@@ -111,6 +111,27 @@ export class PhotoService {
 }
 ```
 
+## Driver-specific imports
+
+When you try to inject the `EntityManager` or `MikroORM` symbols exported from the driver package, Nest.js needs to be aware of those typed. In other words, those driver specific exports need to be specifically registered in the DI container. This module uses automated discovery of the driver type in order to do that, but it fails to work when you use `useFactory` which requires some dependencies.
+
+Instead of relying on this discovery, you can provide the driver type explicitly:
+
+```typescript
+@Module({
+  imports: [
+    MikroOrmModule.forRootAsync({
+      useFactory: (configService: ConfigService) => configService.getOrThrow(ConfigKey.ORM),
+      inject: [ConfigService],
+      driver: PostgreSqlDriver,
+    }),
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+```
+
 ## Auto entities automatically
 
 Manually adding entities to the entities array of the connection options can be 
@@ -255,6 +276,7 @@ export class AppModule {}
 Or, if you're using the Async provider:
 ```typescript
 import { Scope } from '@nestjs/common';
+import { PostgreSqlDriver } from '@mikro-orm/postgresql';
 
 @Module({
   imports: [
@@ -342,7 +364,7 @@ More information about [enableShutdownHooks](https://docs.nestjs.com/fundamental
 
 ## 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`
+You can define multiple database connections by registering multiple `MikroOrmModule`'s, each with a unique `contextName`. You will need to disable the automatic request context middleware by setting `registerRequestContext` to `false`, as it wouldn't work with this approach - note that this needs to be part of all your `MikroOrmModule`s with non-default `contextName`. To have the same automatic request context behaviour, you must register `MikroOrmModule` with `forMiddleware()` instead:
 
 ```typescript
 @Module({
@@ -365,6 +387,21 @@ You can define multiple database connections by registering multiple `MikroOrmMo
 export class AppModule {}
 ```
 
+Since MikroORM v6.4, you can also define [multiple configurations](https://mikro-orm.io/docs/quick-start#configuration-file-structure) as part of a single ORM config. If you want to use such a combined config file, you need to destructure the result, since it will be also an array:
+
+```typescript
+@Module({
+  imports: [
+    // `config` exports an array of configs
+    ...MikroOrmModule.forRoot(config),
+    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
@@ -407,6 +444,17 @@ export class PhotoService {
 }
 ```
 
+You can use the `@InjectMikroORMs` decorator to get all registered MikroORM instances:
+
+```typescript
+@Injectable()
+export class MyService {
+
+  constructor(@InjectMikroORMs() private readonly orms: MikroORM[]) { }
+
+}
+```
+
 ## Testing
 
 The `nestjs-mikro-orm` package exposes `getRepositoryToken()` function that returns prepared token based on a given entity to allow mocking the repository.

package/middleware.helper.d.ts

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

package/middleware.helper.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.forRoutesPath = void 0;
+exports.forRoutesPath = forRoutesPath;
+const common_1 = require("@nestjs/common");
 function forRoutesPath(options, consumer) {
-    const isNestMiddleware = (consumer) => {
-        return typeof consumer.httpAdapter === 'object';
-    };
-    const usingFastify = (consumer) => {
+    if (options.forRoutesPath) {
+        return options.forRoutesPath;
+    }
+    // detect nest v11 based on a newly added enum value
+    if (common_1.HttpStatus.MULTI_STATUS) {
+        return '{*all}';
+    }
+    const isFastify = (consumer) => {
+        if (typeof consumer.httpAdapter !== 'object') {
+            return false;
+        }
         return consumer.httpAdapter.constructor.name.toLowerCase().startsWith('fastify');
     };
-    return options.forRoutesPath ??
-        (isNestMiddleware(consumer) && usingFastify(consumer) ? '(.*)' : '*');
+    return isFastify(consumer) ? '(.*)' : '*';
 }
-exports.forRoutesPath = forRoutesPath;

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

@@ -1,7 +1,7 @@
-import { type DynamicModule, type MiddlewareConsumer, type OnApplicationShutdown } from '@nestjs/common';
+import { type DynamicModule, type MiddlewareConsumer, type NestModule, type OnApplicationShutdown } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
 import { MikroOrmModuleOptions, type MikroOrmModuleAsyncOptions, type MikroOrmModuleSyncOptions } from './typings';
-export declare class MikroOrmCoreModule implements OnApplicationShutdown {
+export declare class MikroOrmCoreModule implements NestModule, OnApplicationShutdown {
     private readonly options;
     private readonly moduleRef;
     constructor(options: MikroOrmModuleOptions, moduleRef: ModuleRef);

package/mikro-orm-core.module.js

@@ -21,13 +21,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -71,6 +81,28 @@ let MikroOrmCoreModule = MikroOrmCoreModule_1 = class MikroOrmCoreModule {
     }
     static async forRoot(options) {
         const contextName = this.setContextName(options?.contextName);
+        if (options?.driver && !contextName) {
+            const packageName = PACKAGES[options.driver.name];
+            const driverPackage = await tryRequire(packageName);
+            if (driverPackage) {
+                return {
+                    module: MikroOrmCoreModule_1,
+                    providers: [
+                        { provide: mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS, useValue: options || {} },
+                        (0, mikro_orm_providers_1.createMikroOrmProvider)(contextName),
+                        (0, mikro_orm_providers_1.createMikroOrmProvider)(contextName, driverPackage.MikroORM),
+                        (0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, core_1.EntityManager),
+                        (0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, driverPackage.EntityManager),
+                    ],
+                    exports: [
+                        core_1.MikroORM,
+                        core_1.EntityManager,
+                        driverPackage.EntityManager,
+                        driverPackage.MikroORM,
+                    ],
+                };
+            }
+        }
         const knex = await tryRequire('@mikro-orm/knex');
         const mongo = await tryRequire('@mikro-orm/mongodb');
         const em = await this.createEntityManager(options);
@@ -118,6 +150,30 @@ let MikroOrmCoreModule = MikroOrmCoreModule_1 = class MikroOrmCoreModule {
     }
     static async forRootAsync(options) {
         const contextName = this.setContextName(options?.contextName);
+        if (options?.driver && !contextName) {
+            const packageName = PACKAGES[options.driver.name];
+            const driverPackage = await tryRequire(packageName);
+            if (driverPackage) {
+                return {
+                    module: MikroOrmCoreModule_1,
+                    imports: options.imports || [],
+                    providers: [
+                        ...(options.providers || []),
+                        ...(0, mikro_orm_providers_1.createAsyncProviders)({ ...options, contextName: options.contextName }),
+                        (0, mikro_orm_providers_1.createMikroOrmProvider)(contextName),
+                        (0, mikro_orm_providers_1.createMikroOrmProvider)(contextName, driverPackage.MikroORM),
+                        (0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, core_1.EntityManager),
+                        (0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, driverPackage.EntityManager),
+                    ],
+                    exports: [
+                        core_1.MikroORM,
+                        core_1.EntityManager,
+                        driverPackage.EntityManager,
+                        driverPackage.MikroORM,
+                    ],
+                };
+            }
+        }
         const knex = await tryRequire('@mikro-orm/knex');
         const mongo = await tryRequire('@mikro-orm/mongodb');
         const em = await this.createEntityManager(options);
@@ -192,7 +248,10 @@ let MikroOrmCoreModule = MikroOrmCoreModule_1 = class MikroOrmCoreModule {
             return config?.getDriver().createEntityManager();
         }
         catch {
-            // ignore
+            if (options && 'useFactory' in options && 'inject' in options && options.inject.length > 0) {
+                // eslint-disable-next-line no-console
+                console.warn('Support for driver specific imports in modules defined with `useFactory` and `inject` requires an explicit `driver` option. See https://github.com/mikro-orm/nestjs/pull/204');
+            }
         }
     }
     async onApplicationShutdown() {

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

@@ -1,10 +1,10 @@
-import { type MiddlewareConsumer } from '@nestjs/common';
+import { type MiddlewareConsumer, type NestModule } from '@nestjs/common';
 import type { MikroORM } from '@mikro-orm/core';
 import { MikroOrmMiddlewareModuleOptions } from './typings';
-export declare class MikroOrmMiddlewareModule {
+export declare class MikroOrmMiddlewareModule implements NestModule {
     private readonly options;
     constructor(options: MikroOrmMiddlewareModuleOptions);
-    static forMiddleware(options?: MikroOrmMiddlewareModuleOptions): {
+    static forRoot(options?: MikroOrmMiddlewareModuleOptions): {
         module: typeof MikroOrmMiddlewareModule;
         providers: ({
             provide: symbol;

package/mikro-orm-middleware.module.js

@@ -22,10 +22,7 @@ let MikroOrmMiddlewareModule = MikroOrmMiddlewareModule_1 = class MikroOrmMiddle
     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
+    static forRoot(options) {
         const inject = mikro_orm_common_1.CONTEXT_NAMES.map(name => (0, mikro_orm_common_1.getMikroORMToken)(name));
         return {
             module: MikroOrmMiddlewareModule_1,

package/mikro-orm.common.d.ts

@@ -3,9 +3,50 @@ import type { EntityName } from './typings';
 export declare const MIKRO_ORM_MODULE_OPTIONS: unique symbol;
 export declare const CONTEXT_NAMES: string[];
 export declare const logger: Logger;
+/**
+ * Gets the injection token based on context name for the relevant MikroORM provider.
+ * @param name The context name of the database connection.
+ * @returns The MikroORM provider injection token for the supplied context name.
+ */
 export declare const getMikroORMToken: (name: string) => string;
+/**
+ * Injects a MikroORM provider based on the supplied context name.
+ *
+ * @param name The context name of the database connection.
+ * @returns A parameter decorator which will cause NestJS to inject the relevant MikroORM provider.
+ */
 export declare const InjectMikroORM: (name: string) => PropertyDecorator & ParameterDecorator;
+/**
+ * Injects the MikroORMs provider.
+ *
+ * @returns A decorator which will cause NestJS to inject the MikroORMs provider.
+ */
+export declare const InjectMikroORMs: () => PropertyDecorator & ParameterDecorator;
+/**
+ * Gets the injection token based on context name for the relevant EntityManager provider.
+ * @param name The context name of the database connection.
+ * @returns The EntityManager provider injection token for the supplied context name.
+ */
 export declare const getEntityManagerToken: (name: string) => string;
+/**
+ * Injects an EntityManager provider based on the supplied context name.
+ *
+ * @param name The context name of the database connection.
+ * @returns A parameter decorator which will cause NestJS to inject the relevant EntityManager provider.
+ */
 export declare const InjectEntityManager: (name: string) => PropertyDecorator & ParameterDecorator;
+/**
+ * Gets the injection token based on class and optionally based on context name.
+ * @param entity The class of the Entity to use for the injected repository provider.
+ * @param name An optional context name - required for multiple database connections. See: [Multiple Database Connections](https://mikro-orm.io/docs/usage-with-nestjs#multiple-database-connections)
+ * @returns The EntityRepository provider injection token based on the supplied entity and context name.
+ */
 export declare const getRepositoryToken: <T extends object>(entity: EntityName<T>, name?: string) => string;
+/**
+ * Injects an EntityRepository provider.
+ *
+ * @param entity The class of the Entity to use for the injected repository provider.
+ * @param name An optional context name - required for multiple database connections. See: [Multiple Database Connections](https://mikro-orm.io/docs/usage-with-nestjs#multiple-database-connections)
+ * @returns A parameter decorator which will cause NestJS to inject the relevant EntityRepository provider.
+ */
 export declare const InjectRepository: <T extends object>(entity: EntityName<T>, name?: string) => PropertyDecorator & ParameterDecorator;

package/mikro-orm.common.js

@@ -1,23 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectRepository = exports.getRepositoryToken = exports.InjectEntityManager = exports.getEntityManagerToken = exports.InjectMikroORM = exports.getMikroORMToken = exports.logger = exports.CONTEXT_NAMES = exports.MIKRO_ORM_MODULE_OPTIONS = void 0;
+exports.InjectRepository = exports.getRepositoryToken = exports.InjectEntityManager = exports.getEntityManagerToken = exports.InjectMikroORMs = 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.CONTEXT_NAMES = [];
 exports.logger = new common_1.Logger(core_1.MikroORM.name);
+/**
+ * Gets the injection token based on context name for the relevant MikroORM provider.
+ * @param name The context name of the database connection.
+ * @returns The MikroORM provider injection token for the supplied context name.
+ */
 const getMikroORMToken = (name) => `${name}_MikroORM`;
 exports.getMikroORMToken = getMikroORMToken;
+/**
+ * Injects a MikroORM provider based on the supplied context name.
+ *
+ * @param name The context name of the database connection.
+ * @returns A parameter decorator which will cause NestJS to inject the relevant MikroORM provider.
+ */
 const InjectMikroORM = (name) => (0, common_1.Inject)((0, exports.getMikroORMToken)(name));
 exports.InjectMikroORM = InjectMikroORM;
+/**
+ * Injects the MikroORMs provider.
+ *
+ * @returns A decorator which will cause NestJS to inject the MikroORMs provider.
+ */
+const InjectMikroORMs = () => (0, common_1.Inject)('MikroORMs');
+exports.InjectMikroORMs = InjectMikroORMs;
+/**
+ * Gets the injection token based on context name for the relevant EntityManager provider.
+ * @param name The context name of the database connection.
+ * @returns The EntityManager provider injection token for the supplied context name.
+ */
 const getEntityManagerToken = (name) => `${name}_EntityManager`;
 exports.getEntityManagerToken = getEntityManagerToken;
+/**
+ * Injects an EntityManager provider based on the supplied context name.
+ *
+ * @param name The context name of the database connection.
+ * @returns A parameter decorator which will cause NestJS to inject the relevant EntityManager provider.
+ */
 const InjectEntityManager = (name) => (0, common_1.Inject)((0, exports.getEntityManagerToken)(name));
 exports.InjectEntityManager = InjectEntityManager;
+/**
+ * Gets the injection token based on class and optionally based on context name.
+ * @param entity The class of the Entity to use for the injected repository provider.
+ * @param name An optional context name - required for multiple database connections. See: [Multiple Database Connections](https://mikro-orm.io/docs/usage-with-nestjs#multiple-database-connections)
+ * @returns The EntityRepository provider injection token based on the supplied entity and context name.
+ */
 const getRepositoryToken = (entity, name) => {
     const suffix = name ? `_${name}` : '';
     return `${core_1.Utils.className(entity)}Repository${suffix}`;
 };
 exports.getRepositoryToken = getRepositoryToken;
+/**
+ * Injects an EntityRepository provider.
+ *
+ * @param entity The class of the Entity to use for the injected repository provider.
+ * @param name An optional context name - required for multiple database connections. See: [Multiple Database Connections](https://mikro-orm.io/docs/usage-with-nestjs#multiple-database-connections)
+ * @returns A parameter decorator which will cause NestJS to inject the relevant EntityRepository provider.
+ */
 const InjectRepository = (entity, name) => (0, common_1.Inject)((0, exports.getRepositoryToken)(entity, name));
 exports.InjectRepository = InjectRepository;

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

@@ -4,7 +4,7 @@ export declare class MikroOrmEntitiesStorage {
     private static readonly storage;
     private static shouldClear;
     static addEntity(entity: EntityName<AnyEntity>, contextName?: string): void;
-    static getEntities(contextName?: string): never[] | IterableIterator<EntityName<Partial<any>>>;
+    static getEntities(contextName?: string): never[] | SetIterator<EntityName<Partial<any>>>;
     static clear(contextName?: string): void;
     /**
      * When the `addEntity` is called next, the storage will be cleared automatically before it.

package/mikro-orm.module.d.ts

@@ -1,14 +1,16 @@
 import { type AnyEntity } from '@mikro-orm/core';
 import { type DynamicModule } from '@nestjs/common';
-import type { EntityName, MikroOrmMiddlewareModuleOptions, MikroOrmModuleAsyncOptions, MikroOrmModuleFeatureOptions, MikroOrmModuleSyncOptions } from './typings';
+import { EntityName, MikroOrmModuleAsyncOptions, MikroOrmModuleFeatureOptions, MikroOrmModuleSyncOptions, MikroOrmMiddlewareModuleOptions, MaybePromise } from './typings';
 export declare class MikroOrmModule {
     /**
      * Clears the entity storage. This is useful for testing purposes, when you want to isolate the tests.
      * Keep in mind that this should be called when using a test runner that keeps the context alive between tests (like Vitest with threads disabled).
      */
     static clearStorage(contextName?: string): void;
-    static forRoot(options?: MikroOrmModuleSyncOptions): DynamicModule;
-    static forRootAsync(options: MikroOrmModuleAsyncOptions): DynamicModule;
+    static forRoot(options?: MikroOrmModuleSyncOptions): MaybePromise<DynamicModule>;
+    static forRoot(options?: MikroOrmModuleSyncOptions[]): MaybePromise<DynamicModule>[];
+    static forRootAsync(options: MikroOrmModuleAsyncOptions): MaybePromise<DynamicModule>;
+    static forRootAsync(options: MikroOrmModuleAsyncOptions[]): MaybePromise<DynamicModule>[];
     static forFeature(options: EntityName<AnyEntity>[] | MikroOrmModuleFeatureOptions, contextName?: string): DynamicModule;
     static forMiddleware(options?: MikroOrmMiddlewareModuleOptions): DynamicModule;
 }

package/mikro-orm.module.js

@@ -23,16 +23,16 @@ let MikroOrmModule = MikroOrmModule_1 = class MikroOrmModule {
         mikro_orm_entities_storage_1.MikroOrmEntitiesStorage.clear(contextName);
     }
     static forRoot(options) {
-        return {
-            module: MikroOrmModule_1,
-            imports: [mikro_orm_core_module_1.MikroOrmCoreModule.forRoot(options)],
-        };
+        if (Array.isArray(options)) {
+            return options.map(o => mikro_orm_core_module_1.MikroOrmCoreModule.forRoot(o));
+        }
+        return mikro_orm_core_module_1.MikroOrmCoreModule.forRoot(options);
     }
     static forRootAsync(options) {
-        return {
-            module: MikroOrmModule_1,
-            imports: [mikro_orm_core_module_1.MikroOrmCoreModule.forRootAsync(options)],
-        };
+        if (Array.isArray(options)) {
+            return options.map(o => mikro_orm_core_module_1.MikroOrmCoreModule.forRootAsync(o));
+        }
+        return mikro_orm_core_module_1.MikroOrmCoreModule.forRootAsync(options);
     }
     static forFeature(options, contextName) {
         const entities = Array.isArray(options) ? options : (options.entities || []);
@@ -50,10 +50,7 @@ let MikroOrmModule = MikroOrmModule_1 = class MikroOrmModule {
         };
     }
     static forMiddleware(options) {
-        return {
-            module: MikroOrmModule_1,
-            imports: [mikro_orm_middleware_module_1.MikroOrmMiddlewareModule.forMiddleware(options)],
-        };
+        return mikro_orm_middleware_module_1.MikroOrmMiddlewareModule.forRoot(options);
     }
 };
 exports.MikroOrmModule = MikroOrmModule;

package/mikro-orm.providers.d.ts

@@ -1,8 +1,8 @@
-import { EntityManager, type AnyEntity } from '@mikro-orm/core';
+import { EntityManager, type AnyEntity, type ForkOptions } from '@mikro-orm/core';
 import { Scope, type Provider, type Type } from '@nestjs/common';
 import type { EntityName, MikroOrmModuleAsyncOptions } from './typings';
 export declare function createMikroOrmProvider(contextName?: string, type?: Type): Provider;
-export declare function createEntityManagerProvider(scope?: Scope, entityManager?: Type, contextName?: string): Provider<EntityManager>;
+export declare function createEntityManagerProvider(scope?: Scope, entityManager?: Type, contextName?: string, forkOptions?: ForkOptions): 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,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMikroOrmRepositoryProviders = exports.createAsyncProviders = exports.createMikroOrmAsyncOptionsProvider = exports.createEntityManagerProvider = exports.createMikroOrmProvider = void 0;
+exports.createMikroOrmProvider = createMikroOrmProvider;
+exports.createEntityManagerProvider = createEntityManagerProvider;
+exports.createMikroOrmAsyncOptionsProvider = createMikroOrmAsyncOptionsProvider;
+exports.createAsyncProviders = createAsyncProviders;
+exports.createMikroOrmRepositoryProviders = createMikroOrmRepositoryProviders;
 const core_1 = require("@mikro-orm/core");
 const mikro_orm_common_1 = require("./mikro-orm.common");
 const common_1 = require("@nestjs/common");
@@ -25,15 +29,14 @@ function createMikroOrmProvider(contextName, type = core_1.MikroORM) {
             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;
+                options = config.getAll();
             }
             return core_1.MikroORM.init(options);
         },
         inject: [mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS],
     };
 }
-exports.createMikroOrmProvider = createMikroOrmProvider;
-function createEntityManagerProvider(scope = common_1.Scope.DEFAULT, entityManager = core_1.EntityManager, contextName) {
+function createEntityManagerProvider(scope = common_1.Scope.DEFAULT, entityManager = core_1.EntityManager, contextName, forkOptions) {
     if (!contextName && entityManager !== core_1.EntityManager) {
         return {
             provide: entityManager,
@@ -45,11 +48,10 @@ function createEntityManagerProvider(scope = common_1.Scope.DEFAULT, entityManag
     return {
         provide: contextName ? (0, mikro_orm_common_1.getEntityManagerToken)(contextName) : entityManager,
         scope,
-        useFactory: (orm) => scope === common_1.Scope.DEFAULT ? orm.em : orm.em.fork(),
+        useFactory: (orm) => scope === common_1.Scope.DEFAULT ? orm.em : orm.em.fork(forkOptions),
         inject: [contextName ? (0, mikro_orm_common_1.getMikroORMToken)(contextName) : core_1.MikroORM],
     };
 }
-exports.createEntityManagerProvider = createEntityManagerProvider;
 function createMikroOrmAsyncOptionsProvider(options) {
     if (options.useFactory) {
         return {
@@ -73,7 +75,6 @@ function createMikroOrmAsyncOptionsProvider(options) {
         inject,
     };
 }
-exports.createMikroOrmAsyncOptionsProvider = createMikroOrmAsyncOptionsProvider;
 function createAsyncProviders(options) {
     if (options.useExisting || options.useFactory) {
         return [createMikroOrmAsyncOptionsProvider(options)];
@@ -86,7 +87,6 @@ function createAsyncProviders(options) {
     }
     throw new Error('Invalid MikroORM async options: one of `useClass`, `useExisting` or `useFactory` should be defined.');
 }
-exports.createAsyncProviders = createAsyncProviders;
 function createMikroOrmRepositoryProviders(entities, contextName) {
     const metadata = Object.values(core_1.MetadataStorage.getMetadata());
     const providers = [];
@@ -109,4 +109,3 @@ function createMikroOrmRepositoryProviders(entities, contextName) {
     });
     return providers;
 }
-exports.createMikroOrmRepositoryProviders = createMikroOrmRepositoryProviders;

package/multiple-mikro-orm.middleware.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultipleMikroOrmMiddleware = void 0;
 const core_1 = require("@mikro-orm/core");
 const common_1 = require("@nestjs/common");
+const mikro_orm_common_1 = require("./mikro-orm.common");
 let MultipleMikroOrmMiddleware = class MultipleMikroOrmMiddleware {
     constructor(orm) {
         this.orm = orm;
@@ -26,6 +27,6 @@ let MultipleMikroOrmMiddleware = class MultipleMikroOrmMiddleware {
 exports.MultipleMikroOrmMiddleware = MultipleMikroOrmMiddleware;
 exports.MultipleMikroOrmMiddleware = MultipleMikroOrmMiddleware = __decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)('MikroORMs')),
+    __param(0, (0, mikro_orm_common_1.InjectMikroORMs)()),
     __metadata("design:paramtypes", [Array])
 ], MultipleMikroOrmMiddleware);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/nestjs",
-  "version": "6.0.2",
+  "version": "6.1.1",
   "license": "MIT",
   "author": {
     "name": "Martin Adamek",
@@ -40,32 +40,32 @@
     "lint": "eslint src/**/*.ts"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "^6.0.0 || ^6.0.0-dev.0",
-    "@nestjs/common": "^10.0.0",
-    "@nestjs/core": "^10.0.0"
+    "@mikro-orm/core": "^6.0.0 || ^6.0.0-dev.0 || ^7.0.0-dev.0",
+    "@nestjs/common": "^10.0.0 || ^11.0.5",
+    "@nestjs/core": "^10.0.0 || ^11.0.5"
   },
   "devDependencies": {
     "@mikro-orm/core": "^6.2.7",
     "@mikro-orm/sqlite": "^6.2.7",
-    "@nestjs/common": "^10.3.8",
-    "@nestjs/core": "^10.3.8",
-    "@nestjs/platform-express": "^10.3.8",
-    "@nestjs/testing": "^10.3.8",
+    "@nestjs/common": "^11.0.5",
+    "@nestjs/core": "^11.0.5",
+    "@nestjs/platform-express": "^11.0.5",
+    "@nestjs/testing": "^11.0.5",
+    "@stylistic/eslint-plugin-ts": "^3.0.1",
     "@types/jest": "^29.5.12",
-    "@types/node": "^20.12.12",
+    "@types/node": "^22.0.0",
     "@types/supertest": "^6.0.2",
-    "@typescript-eslint/eslint-plugin": "~7.12.0",
-    "@typescript-eslint/parser": "~7.12.0",
     "conventional-changelog": "^6.0.0",
     "conventional-changelog-cli": "^5.0.0",
-    "eslint": "^8.57.0",
-    "eslint-plugin-import": "^2.29.1",
+    "eslint": "^9.19.0",
+    "eslint-plugin-import": "^2.31.0",
     "jest": "^29.7.0",
     "rxjs": "^7.8.1",
     "supertest": "^7.0.0",
     "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
-    "typescript": "5.4.5"
+    "typescript": "5.7.3",
+    "typescript-eslint": "^8.22.0"
   },
   "commitlint": {
     "extends": [
@@ -105,5 +105,5 @@
   "engines": {
     "node": ">= 18.12.0"
   },
-  "packageManager": "yarn@4.2.2"
+  "packageManager": "yarn@4.6.0"
 }

package/typings.d.ts

@@ -1,11 +1,27 @@
-import type { AnyEntity, EntityName as CoreEntityName, EntitySchema, IDatabaseDriver, Options } from '@mikro-orm/core';
+import type { AnyEntity, Constructor, EntityName as CoreEntityName, EntitySchema, ForkOptions, IDatabaseDriver, Options } from '@mikro-orm/core';
 import type { MiddlewareConsumer, ModuleMetadata, Scope, Type } from '@nestjs/common';
 import type { AbstractHttpAdapter } from '@nestjs/core';
+export type MaybePromise<T> = T | Promise<T>;
 export interface NestMiddlewareConsumer extends MiddlewareConsumer {
     httpAdapter: AbstractHttpAdapter;
 }
 type MikroOrmNestScopeOptions = {
+    /**
+     * The NestJS provider scope to use for the EntityManager (and any subsequent downstream records).
+     *
+     * This scope will also impact the scope of Entity Repositories as they depend on the EntityManager.
+     *
+     * @see [NestJS Scope Hierarchy](https://docs.nestjs.com/fundamentals/injection-scopes#scope-hierarchy)
+     */
     scope?: Scope;
+    /**
+     * An optional configuration object to use when forking the Event Manager if it is configured with a scope other than Scope.DEFAULT
+     *
+     * This configuration option has no effect when the scope is set to Scope.DEFAULT.
+     *
+     * https://mikro-orm.io/api/core/interface/ForkOptions
+     */
+    forkOptions?: ForkOptions;
 };
 export type MikroOrmMiddlewareModuleOptions = {
     /**
@@ -19,10 +35,27 @@ export type MikroOrmMiddlewareModuleOptions = {
 };
 export type MikroOrmModuleOptions<D extends IDatabaseDriver = IDatabaseDriver> = {
     registerRequestContext?: boolean;
+    /**
+     * Specifies whether or not to automatically load the entities based on MikroOrmModule.forFeature invocations.
+     *
+     * @see [MikroOrm - NestJS - Load Entities Automatically](https://mikro-orm.io/docs/usage-with-nestjs#load-entities-automatically)
+     *
+     * @default false
+     */
     autoLoadEntities?: boolean;
 } & Options<D> & MikroOrmMiddlewareModuleOptions;
 export interface MikroOrmModuleFeatureOptions {
+    /**
+     * The entities to provide an EntityRepository for.
+     *
+     * @see [MikroOrm - NestJS - Repositories](https://mikro-orm.io/docs/usage-with-nestjs#repositories)
+     */
     entities?: EntityName<AnyEntity>[];
+    /**
+     * The context (database connection) to use for the entity repository.
+     *
+     * @see [MikroOrm - NestJS - Multiple Database Connections](https://mikro-orm.io/docs/usage-with-nestjs#multiple-database-connections)
+     */
     contextName?: string;
 }
 export interface MikroOrmOptionsFactory<D extends IDatabaseDriver = IDatabaseDriver> {
@@ -31,10 +64,18 @@ export interface MikroOrmOptionsFactory<D extends IDatabaseDriver = IDatabaseDri
 export interface MikroOrmModuleSyncOptions extends MikroOrmModuleOptions, MikroOrmNestScopeOptions {
 }
 export interface MikroOrmModuleAsyncOptions<D extends IDatabaseDriver = IDatabaseDriver> extends Pick<ModuleMetadata, 'imports' | 'providers'>, MikroOrmNestScopeOptions {
+    /**
+     * The context name (database connection) to specify for this instance.
+     *
+     * When injecting repositories or entity manager instances, this context name will need to be specified where there are multiple datbaase connections.
+     *
+     * @see [MikroOrm - NestJS - Multiple Database Connections](https://mikro-orm.io/docs/usage-with-nestjs#multiple-database-connections)
+     */
     contextName?: string;
     useExisting?: Type<MikroOrmOptionsFactory<D>>;
     useClass?: Type<MikroOrmOptionsFactory<D>>;
     useFactory?: (...args: any[]) => Promise<Omit<MikroOrmModuleOptions<D>, 'contextName'>> | Omit<MikroOrmModuleOptions<D>, 'contextName'>;
+    driver?: Constructor<D>;
     inject?: any[];
 }
 export declare type EntityName<T extends AnyEntity<T>> = CoreEntityName<T> | EntitySchema;