@mikro-orm/nestjs 6.1.1 → 7.0.0-dev.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Dario Mancuso, Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -54,7 +54,7 @@ Once the installation process is completed, we can import the `MikroOrmModule` i
 export class AppModule {}
 ```
 
-The `forRoot()` method accepts the same configuration object as `init()` from the MikroORM package. 
+The `forRoot()` method accepts the same configuration object as `init()` from the MikroORM package.
 You can also omit the parameter to use the CLI config.
 
 Afterward, the `EntityManager` will be available to inject across entire project (without importing any module elsewhere).
@@ -132,18 +132,18 @@ Instead of relying on this discovery, you can provide the driver type explicitly
 export class AppModule {}
 ```
 
-## Auto entities automatically
+## Load entities automatically
 
-Manually adding entities to the entities array of the connection options can be 
-tedious. In addition, referencing entities from the root module breaks application 
-domain boundaries and causes leaking implementation details to other parts of the 
+Manually adding entities to the entities array of the connection options can be
+tedious. In addition, referencing entities from the root module breaks application
+domain boundaries and causes leaking implementation details to other parts of the
 application. To solve this issue, static glob paths can be used.
 
-Note, however, that glob paths are not supported by webpack, so if you are building 
-your application within a monorepo, you won't be able to use them. To address this 
-issue, an alternative solution is provided. To automatically load entities, set the 
-`autoLoadEntities` property of the configuration object (passed into the `forRoot()` 
-method) to `true`, as shown below: 
+Note, however, that glob paths are not supported by webpack, so if you are building
+your application within a monorepo, you won't be able to use them. To address this
+issue, an alternative solution is provided. To automatically load entities, set the
+`autoLoadEntities` property of the configuration object (passed into the `forRoot()`
+method) to `true`, as shown below:
 
 ```ts
 @Module({
@@ -157,31 +157,31 @@ method) to `true`, as shown below:
 export class AppModule {}
 ```
 
-With that option specified, every entity registered through the `forFeature()` 
-method will be automatically added to the entities array of the configuration 
+With that option specified, every entity registered through the `forFeature()`
+method will be automatically added to the entities array of the configuration
 object.
 
-> Note that entities that aren't registered through the `forFeature()` method, but 
-> are only referenced from the entity (via a relationship), won't be included by 
+> Note that entities that aren't registered through the `forFeature()` method, but
+> are only referenced from the entity (via a relationship), won't be included by
 > way of the `autoLoadEntities` setting.
 
-> Using `autoLoadEntities` also has no effect on the MikroORM CLI - for that we 
+> Using `autoLoadEntities` also has no effect on the MikroORM CLI - for that we
 > still need CLI config with the full list of entities. On the other hand, we can
 > use globs there, as the CLI won't go thru webpack.
 
 ## Request scoped handlers in queues
 
 As mentioned in the docs, we need a clean state for each request. That is handled
-automatically thanks to the `RequestContext` helper registered via middleware. 
+automatically thanks to the `RequestContext` helper registered via middleware.
 
 But middlewares are executed only for regular HTTP request handles, what if we need
-a request scoped method outside of that? One example of that is queue handlers or 
-scheduled tasks. 
+a request scoped method outside of that? One example of that is queue handlers or
+scheduled tasks.
 
-We can use the `@UseRequestContext()` decorator. It requires you to first inject the
-`MikroORM` instance to current context, it will be then used to create the context 
-for you. Under the hood, the decorator will register new request context for your 
-method and execute it inside the context. 
+We can use the `@CreateRequestContext()` decorator. It requires you to first inject the
+`MikroORM` instance to current context, it will be then used to create the context
+for you. Under the hood, the decorator will register new request context for your
+method and execute it inside the context.
 
 ```ts
 @Injectable()
@@ -189,7 +189,7 @@ export class MyService {
 
   constructor(private readonly orm: MikroORM) { }
 
-  @UseRequestContext()
+  @CreateRequestContext()
   async doSomething() {
     // this will be executed in a separate context
   }
@@ -209,10 +209,10 @@ 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;
 
@@ -274,6 +274,7 @@ export class AppModule {}
 ```
 
 Or, if you're using the Async provider:
+
 ```typescript
 import { Scope } from '@nestjs/common';
 import { PostgreSqlDriver } from '@mikro-orm/postgresql';
@@ -307,8 +308,8 @@ decorator by naming our repositories the same way as `getRepositoryToken()` meth
 export const getRepositoryToken = <T> (entity: EntityName<T>) => `${Utils.className(entity)}Repository`;
 ```
 
-In other words, as long as we name the repository same was as the entity is called, 
-appending `Repository` suffix, the repository will be registered automatically in 
+In other words, as long as we name the repository same was as the entity is called,
+appending `Repository` suffix, the repository will be registered automatically in
 the Nest.js DI container.
 
 `**./author.entity.ts**`
@@ -474,8 +475,8 @@ export class PhotoModule {}
 
 ## 🤝 Contributing
 
-Contributions, issues and feature requests are welcome. Please read 
-[CONTRIBUTING.md](CONTRIBUTING.md) 
+Contributions, issues and feature requests are welcome. Please read
+[CONTRIBUTING.md](CONTRIBUTING.md)
 for details on the process for submitting pull requests to us.
 
 ## Authors

package/index.d.ts

@@ -1,5 +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';
+export * from './mikro-orm.module.js';
+export * from './mikro-orm.common.js';
+export * from './mikro-orm.middleware.js';
+export * from './multiple-mikro-orm.middleware.js';
+export * from './typings.js';

package/index.js

@@ -1,21 +1,5 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = 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];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-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);
+export * from './mikro-orm.module.js';
+export * from './mikro-orm.common.js';
+export * from './mikro-orm.middleware.js';
+export * from './multiple-mikro-orm.middleware.js';
+export * from './typings.js';

package/middleware.helper.d.ts

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

package/middleware.helper.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.forRoutesPath = forRoutesPath;
-const common_1 = require("@nestjs/common");
-function forRoutesPath(options, consumer) {
+import { HttpStatus } from '@nestjs/common';
+export function forRoutesPath(options, consumer) {
     if (options.forRoutesPath) {
         return options.forRoutesPath;
     }
     // detect nest v11 based on a newly added enum value
-    if (common_1.HttpStatus.MULTI_STATUS) {
+    if (HttpStatus.MULTI_STATUS) {
         return '{*all}';
     }
     const isFastify = (consumer) => {

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

@@ -1,11 +1,11 @@
 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';
+import type { MikroOrmModuleOptions, MikroOrmModuleAsyncOptions, MikroOrmModuleSyncOptions } from './typings.js';
 export declare class MikroOrmCoreModule implements NestModule, OnApplicationShutdown {
     private readonly options;
     private readonly moduleRef;
     constructor(options: MikroOrmModuleOptions, moduleRef: ModuleRef);
-    static forRoot(options?: MikroOrmModuleSyncOptions): Promise<DynamicModule>;
+    static forRoot(options: MikroOrmModuleSyncOptions): Promise<DynamicModule>;
     static forRootAsync(options: MikroOrmModuleAsyncOptions): Promise<DynamicModule>;
     /**
      * Tries to create the driver instance to use the actual entity manager implementation for DI symbol.

package/mikro-orm-core.module.js

@@ -1,43 +1,9 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = 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];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 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 __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);
 };
@@ -45,181 +11,87 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 var MikroOrmCoreModule_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MikroOrmCoreModule = void 0;
-const core_1 = require("@mikro-orm/core");
-const common_1 = require("@nestjs/common");
-const core_2 = require("@nestjs/core");
-const middleware_helper_1 = require("./middleware.helper");
-const mikro_orm_common_1 = require("./mikro-orm.common");
-const mikro_orm_entities_storage_1 = require("./mikro-orm.entities.storage");
-const mikro_orm_middleware_1 = require("./mikro-orm.middleware");
-const mikro_orm_providers_1 = require("./mikro-orm.providers");
-async function tryRequire(name) {
-    try {
-        return await Promise.resolve(`${name}`).then(s => __importStar(require(s)));
-    }
-    catch {
-        return undefined; // ignore, optional dependency
-    }
-}
-// TODO: provide the package name via some platform method, prefer that over the static map when available
-const PACKAGES = {
-    MongoDriver: '@mikro-orm/mongo',
-    MySqlDriver: '@mikro-orm/mysql',
-    MsSqlDriver: '@mikro-orm/mssql',
-    MariaDbDriver: '@mikro-orm/mariadb',
-    PostgreSqlDriver: '@mikro-orm/postgresql',
-    SqliteDriver: '@mikro-orm/sqlite',
-    LibSqlDriver: '@mikro-orm/libsql',
-    BetterSqliteDriver: '@mikro-orm/better-sqlite',
-};
+import { Configuration, EntityManager, MikroORM } from '@mikro-orm/core';
+import { Global, Inject, Module, RequestMethod, } from '@nestjs/common';
+// oxlint-disable-next-line consistent-type-imports
+import { ModuleRef } from '@nestjs/core';
+import { forRoutesPath } from './middleware.helper.js';
+import { CONTEXT_NAMES, getEntityManagerToken, getMikroORMToken, MIKRO_ORM_MODULE_OPTIONS, } from './mikro-orm.common.js';
+import { MikroOrmEntitiesStorage } from './mikro-orm.entities.storage.js';
+import { MikroOrmMiddleware } from './mikro-orm.middleware.js';
+import { createAsyncProviders, createEntityManagerProvider, createMikroOrmProvider } from './mikro-orm.providers.js';
 let MikroOrmCoreModule = MikroOrmCoreModule_1 = class MikroOrmCoreModule {
+    options;
+    moduleRef;
     constructor(options, moduleRef) {
         this.options = options;
         this.moduleRef = moduleRef;
     }
     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 contextName = this.setContextName(options.contextName);
         const em = await this.createEntityManager(options);
         if (em && !contextName) {
-            const packageName = PACKAGES[em.getDriver().constructor.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,
-                    ],
-                };
-            }
+            return {
+                module: MikroOrmCoreModule_1,
+                providers: [
+                    { provide: MIKRO_ORM_MODULE_OPTIONS, useValue: options || {} },
+                    createMikroOrmProvider(contextName),
+                    createMikroOrmProvider(contextName, em.getDriver().getORMClass()),
+                    createEntityManagerProvider(options.scope, EntityManager),
+                    createEntityManagerProvider(options.scope, em.constructor),
+                ],
+                exports: [MikroORM, EntityManager, em.constructor, em.getDriver().getORMClass()],
+            };
         }
         return {
             module: MikroOrmCoreModule_1,
             providers: [
-                { provide: mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS, useValue: options || {} },
-                (0, mikro_orm_providers_1.createMikroOrmProvider)(contextName),
-                ...(mongo ? [(0, mikro_orm_providers_1.createMikroOrmProvider)(contextName, mongo.MikroORM)] : []),
-                (0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, core_1.EntityManager, contextName),
-                ...(em ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, em.constructor, contextName)] : []),
-                ...(knex ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, knex.EntityManager, contextName)] : []),
-                ...(mongo ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, mongo.EntityManager, contextName)] : []),
+                { provide: MIKRO_ORM_MODULE_OPTIONS, useValue: options || {} },
+                createMikroOrmProvider(contextName),
+                ...(em ? [createMikroOrmProvider(contextName, em.getDriver().getORMClass())] : []),
+                createEntityManagerProvider(options.scope, EntityManager, contextName),
+                ...(em ? [createEntityManagerProvider(options.scope, em.constructor, contextName)] : []),
             ],
             exports: [
-                contextName ? (0, mikro_orm_common_1.getMikroORMToken)(contextName) : core_1.MikroORM,
-                contextName ? (0, mikro_orm_common_1.getEntityManagerToken)(contextName) : core_1.EntityManager,
-                ...(em && !contextName ? [em.constructor] : []),
-                ...(knex && !contextName ? [knex.EntityManager] : []),
-                ...(mongo && !contextName ? [mongo.EntityManager, mongo.MikroORM] : []),
+                contextName ? getMikroORMToken(contextName) : MikroORM,
+                contextName ? getEntityManagerToken(contextName) : EntityManager,
+                ...(em && !contextName ? [em.constructor, em.getDriver().getORMClass()] : []),
             ],
         };
     }
     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 contextName = this.setContextName(options.contextName);
         const em = await this.createEntityManager(options);
         if (em && !contextName) {
-            const packageName = PACKAGES[em.getDriver().constructor.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,
-                    ],
-                };
-            }
+            return {
+                module: MikroOrmCoreModule_1,
+                imports: options.imports || [],
+                providers: [
+                    ...(options.providers || []),
+                    ...createAsyncProviders({ ...options, contextName: options.contextName }),
+                    createMikroOrmProvider(contextName),
+                    createMikroOrmProvider(contextName, em.getDriver().getORMClass()),
+                    createEntityManagerProvider(options.scope, EntityManager),
+                    createEntityManagerProvider(options.scope, em.constructor),
+                ],
+                exports: [MikroORM, EntityManager, em.constructor, em.getDriver().getORMClass()],
+            };
         }
         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),
-                ...(mongo ? [(0, mikro_orm_providers_1.createMikroOrmProvider)(contextName, mongo.MikroORM)] : []),
-                (0, mikro_orm_providers_1.createEntityManagerProvider)(options.scope, core_1.EntityManager, contextName),
-                ...(em ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, em.constructor, contextName)] : []),
-                ...(knex ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, knex.EntityManager, contextName)] : []),
-                ...(mongo ? [(0, mikro_orm_providers_1.createEntityManagerProvider)(options?.scope, mongo.EntityManager, contextName)] : []),
+                ...createAsyncProviders({ ...options, contextName: options.contextName }),
+                createMikroOrmProvider(contextName),
+                ...(em ? [createMikroOrmProvider(contextName, em.getDriver().getORMClass())] : []),
+                createEntityManagerProvider(options.scope, EntityManager, contextName),
+                ...(em ? [createEntityManagerProvider(options.scope, em.constructor, contextName)] : []),
             ],
             exports: [
-                contextName ? (0, mikro_orm_common_1.getMikroORMToken)(contextName) : core_1.MikroORM,
-                contextName ? (0, mikro_orm_common_1.getEntityManagerToken)(contextName) : core_1.EntityManager,
-                ...(em && !contextName ? [em.constructor] : []),
-                ...(knex && !contextName ? [knex.EntityManager] : []),
-                ...(mongo && !contextName ? [mongo.EntityManager, mongo.MikroORM] : []),
+                contextName ? getMikroORMToken(contextName) : MikroORM,
+                contextName ? getEntityManagerToken(contextName) : EntityManager,
+                ...(em && !contextName ? [em.constructor, em.getDriver().getORMClass()] : []),
             ],
         };
     }
@@ -228,64 +100,65 @@ let MikroOrmCoreModule = MikroOrmCoreModule_1 = class MikroOrmCoreModule {
      * This helps with dependency resolution issues when importing the EM from driver package (e.g. `SqlEntityManager`).
      */
     static async createEntityManager(options) {
-        if (options?.contextName) {
+        if (options.contextName) {
             return undefined;
         }
         try {
             let config;
-            if (!options || Object.keys(options).length === 0) {
-                config = await core_1.ConfigurationLoader.getConfiguration(false);
-            }
-            if (!config && 'useFactory' in options) {
-                config = new core_1.Configuration(await options.useFactory(), false);
+            if ('useFactory' in options) {
+                config = new Configuration(await options.useFactory(), false);
             }
-            if (!config && options instanceof core_1.Configuration) {
+            if (!config && options instanceof Configuration) {
                 config = options;
             }
             if (!config && typeof options === 'object' && options && 'driver' in options) {
-                config = new core_1.Configuration(options, false);
+                config = new Configuration(options, false);
             }
             return config?.getDriver().createEntityManager();
         }
         catch {
-            if (options && 'useFactory' in options && 'inject' in options && options.inject.length > 0) {
+            if (options &&
+                'useFactory' in options &&
+                'inject' in options &&
+                !options.driver &&
+                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() {
-        const token = this.options.contextName ? (0, mikro_orm_common_1.getMikroORMToken)(this.options.contextName) : core_1.MikroORM;
+        const token = this.options.contextName ? getMikroORMToken(this.options.contextName) : MikroORM;
         const orm = this.moduleRef.get(token);
         if (orm) {
             await orm.close();
-            mikro_orm_entities_storage_1.MikroOrmEntitiesStorage.clearLater();
+            MikroOrmEntitiesStorage.clearLater();
         }
-        mikro_orm_common_1.CONTEXT_NAMES.length = 0;
+        CONTEXT_NAMES.length = 0;
     }
     configure(consumer) {
         if (this.options.registerRequestContext === false) {
             return;
         }
         consumer
-            .apply(mikro_orm_middleware_1.MikroOrmMiddleware) // register request context automatically
-            .forRoutes({ path: (0, middleware_helper_1.forRoutesPath)(this.options, consumer), method: common_1.RequestMethod.ALL });
+            .apply(MikroOrmMiddleware) // register request context automatically
+            .forRoutes({ path: forRoutesPath(this.options, consumer), method: RequestMethod.ALL });
     }
     static setContextName(contextName) {
         if (!contextName) {
             return;
         }
-        if (mikro_orm_common_1.CONTEXT_NAMES.includes(contextName)) {
+        if (CONTEXT_NAMES.includes(contextName)) {
             throw new Error(`ContextName '${contextName}' already registered`);
         }
-        mikro_orm_common_1.CONTEXT_NAMES.push(contextName);
+        CONTEXT_NAMES.push(contextName);
         return contextName;
     }
 };
-exports.MikroOrmCoreModule = MikroOrmCoreModule;
-exports.MikroOrmCoreModule = MikroOrmCoreModule = MikroOrmCoreModule_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, core_2.ModuleRef])
+MikroOrmCoreModule = MikroOrmCoreModule_1 = __decorate([
+    Global(),
+    Module({}),
+    __param(0, Inject(MIKRO_ORM_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, ModuleRef])
 ], MikroOrmCoreModule);
+export { MikroOrmCoreModule };

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

@@ -1,6 +1,6 @@
 import { type MiddlewareConsumer, type NestModule } from '@nestjs/common';
 import type { MikroORM } from '@mikro-orm/core';
-import { MikroOrmMiddlewareModuleOptions } from './typings';
+import type { MikroOrmMiddlewareModuleOptions } from './typings.js';
 export declare class MikroOrmMiddlewareModule implements NestModule {
     private readonly options;
     constructor(options: MikroOrmMiddlewareModuleOptions);
@@ -13,7 +13,7 @@ export declare class MikroOrmMiddlewareModule implements NestModule {
             inject?: undefined;
         } | {
             provide: string;
-            useFactory: (...args: MikroORM[]) => MikroORM<import("@mikro-orm/core").IDatabaseDriver<import("@mikro-orm/core").Connection>, import("@mikro-orm/core").EntityManager<import("@mikro-orm/core").IDatabaseDriver<import("@mikro-orm/core").Connection>>>[];
+            useFactory: (...args: MikroORM[]) => MikroORM<import("@mikro-orm/core").IDatabaseDriver<import("@mikro-orm/core").Connection>, import("@mikro-orm/core").EntityManager<import("@mikro-orm/core").IDatabaseDriver<import("@mikro-orm/core").Connection>>, (string | import("@mikro-orm/core").EntitySchema<any, never> | import("@mikro-orm/core").EntityClass<Partial<any>>)[]>[];
             inject: string[];
             useValue?: undefined;
         })[];