fix: support forRoot() without options

src/index.ts

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

src/mikro-orm-core.module.ts

@@ -1,23 +1,25 @@
 import { EntityManager, MikroORM, Options } from '@mikro-orm/core';
-import { DynamicModule, Global, MiddlewareConsumer, Module, OnApplicationShutdown, RequestMethod } from '@nestjs/common';
+import { DynamicModule, Global, Inject, MiddlewareConsumer, Module, OnApplicationShutdown, RequestMethod } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
 
 import { MIKRO_ORM_MODULE_OPTIONS } from './mikro-orm.common';
-import { MikroOrmModuleAsyncOptions } from './typings';
+import { MikroOrmModuleAsyncOptions, MikroOrmModuleOptions } from './typings';
 import { createAsyncProviders, createMikroOrmEntityManagerProvider, createMikroOrmProvider } from './mikro-orm.providers';
 import { MikroOrmMiddleware } from './mikro-orm.middleware';
 
 @Global()
 @Module({})
 export class MikroOrmCoreModule implements OnApplicationShutdown {
 
-  constructor(private readonly moduleRef: ModuleRef) { }
+  constructor(@Inject(MIKRO_ORM_MODULE_OPTIONS)
+              private readonly options: MikroOrmModuleOptions,
+              private readonly moduleRef: ModuleRef) { }
 
   static forRoot(options?: Options): DynamicModule {
     return {
       module: MikroOrmCoreModule,
       providers: [
-        { provide: MIKRO_ORM_MODULE_OPTIONS, useValue: options },
+        { provide: MIKRO_ORM_MODULE_OPTIONS, useValue: options || {} },
         createMikroOrmProvider(),
         createMikroOrmEntityManagerProvider(),
         createMikroOrmEntityManagerProvider('SqlEntityManager'),
@@ -52,6 +54,10 @@ export class MikroOrmCoreModule implements OnApplicationShutdown {
   }
 
   configure(consumer: MiddlewareConsumer): void {
+    if (this.options.registerRequestContext === false) {
+      return;
+    }
+
     consumer
       .apply(MikroOrmMiddleware) // register request context automatically
       .forRoutes({ path: '*', method: RequestMethod.ALL });

src/mikro-orm.providers.ts

@@ -7,14 +7,18 @@ import { Provider } from '@nestjs/common';
 export const createMikroOrmProvider = (): Provider => ({
   provide: MikroORM,
   useFactory: async (options?: Options | Configuration) => {
-    if (!options) {
+    if (!options || Object.keys(options).length === 0) {
+      const settings = await ConfigurationLoader.getSettings();
+
+      if (settings.useTsNode) {
+        await ConfigurationLoader.registerTsNode(settings.tsConfigPath);
+      }
+
       options = await ConfigurationLoader.getConfiguration();
+      options.set('logger', logger.log.bind(logger));
     }
 
-    return MikroORM.init({
-      logger: logger.log.bind(logger),
-      ...options,
-    });
+    return MikroORM.init(options);
   },
   inject: [MIKRO_ORM_MODULE_OPTIONS],
 });

src/typings.ts

@@ -1,13 +1,17 @@
 import { Options } from '@mikro-orm/core';
-import { ModuleMetadata, Type } from '@nestjs/common/interfaces';
+import { ModuleMetadata, Type } from '@nestjs/common';
+
+export type MikroOrmModuleOptions = {
+  registerRequestContext?: boolean;
+} & Options;
 
 export interface MikroOrmOptionsFactory {
-  createMikroOrmOptions(): Promise<Options> | Options;
+  createMikroOrmOptions(): Promise<MikroOrmModuleOptions> | MikroOrmModuleOptions;
 }
 
 export interface MikroOrmModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'providers'> {
   useExisting?: Type<MikroOrmOptionsFactory>;
   useClass?: Type<MikroOrmOptionsFactory>;
-  useFactory?: (...args: any[]) => Promise<Options> | Options;
+  useFactory?: (...args: any[]) => Promise<MikroOrmModuleOptions> | MikroOrmModuleOptions;
   inject?: any[];
 }