@mikro-orm/nestjs 4.2.0 → 4.3.1

package/README.md

@@ -300,6 +300,23 @@ export class MyService {
 }
 ```
 
+## App shutdown and cleanup
+
+By default, NestJS does not listen for system process termination signals (for example SIGTERM). Because of this, the MikroORM shutdown logic will never executed if the process is terminated, which could lead to database connections remaining open and consuming resources. To enable this, the `enableShutdownHooks` function needs to be called when starting up the application.
+
+```ts
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  // Starts listening for shutdown hooks
+  app.enableShutdownHooks();
+
+  await app.listen(3000);
+}
+```
+
+More information about [enableShutdownHooks](https://docs.nestjs.com/fundamentals/lifecycle-events#application-shutdown)
+
 ## 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.js

@@ -7,7 +7,7 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     o[k2] = m[k];
 }));
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+    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);

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

@@ -5,8 +5,8 @@ export declare class MikroOrmCoreModule implements OnApplicationShutdown {
     private readonly options;
     private readonly moduleRef;
     constructor(options: MikroOrmModuleOptions, moduleRef: ModuleRef);
-    static forRoot(options?: MikroOrmModuleSyncOptions): DynamicModule;
-    static forRootAsync(options: MikroOrmModuleAsyncOptions): DynamicModule;
+    static forRoot(options?: MikroOrmModuleSyncOptions): Promise<DynamicModule>;
+    static forRootAsync(options: MikroOrmModuleAsyncOptions): Promise<DynamicModule>;
     onApplicationShutdown(): Promise<void>;
     configure(consumer: MiddlewareConsumer): void;
 }

package/mikro-orm-core.module.js

@@ -1,10 +1,29 @@
 "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]; } });
+}) : (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 (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 __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -20,25 +39,46 @@ 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) {
+    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)];
+    }
+    catch (err) {
+        return [];
+    }
+}
 let MikroOrmCoreModule = MikroOrmCoreModule_1 = class MikroOrmCoreModule {
     constructor(options, moduleRef) {
         this.options = options;
         this.moduleRef = moduleRef;
     }
-    static forRoot(options) {
+    static async forRoot(options) {
         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),
-                mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options === null || options === void 0 ? void 0 : options.scope, 'SqlEntityManager'),
-                mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options === null || options === void 0 ? void 0 : options.scope, 'MongoEntityManager'),
+                ...(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))),
+            ],
+            exports: [
+                core_1.MikroORM,
+                core_1.EntityManager,
+                ...(await whenModuleAvailable(EntityManagerModuleName.Knex, ({ SqlEntityManager }) => SqlEntityManager)),
+                ...(await whenModuleAvailable(EntityManagerModuleName.MongoDb, ({ MongoEntityManager }) => MongoEntityManager)),
             ],
-            exports: [core_1.MikroORM, core_1.EntityManager, 'SqlEntityManager', 'MongoEntityManager'],
         };
     }
-    static forRootAsync(options) {
+    static async forRootAsync(options) {
         return {
             module: MikroOrmCoreModule_1,
             imports: options.imports || [],
@@ -47,10 +87,15 @@ let MikroOrmCoreModule = MikroOrmCoreModule_1 = class MikroOrmCoreModule {
                 ...mikro_orm_providers_1.createAsyncProviders(options),
                 mikro_orm_providers_1.createMikroOrmProvider(),
                 mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options.scope),
-                mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options.scope, 'SqlEntityManager'),
-                mikro_orm_providers_1.createMikroOrmEntityManagerProvider(options.scope, 'MongoEntityManager'),
+                ...(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))),
+            ],
+            exports: [
+                core_1.MikroORM,
+                core_1.EntityManager,
+                ...(await whenModuleAvailable(EntityManagerModuleName.Knex, ({ SqlEntityManager }) => SqlEntityManager)),
+                ...(await whenModuleAvailable(EntityManagerModuleName.MongoDb, ({ MongoEntityManager }) => MongoEntityManager)),
             ],
-            exports: [core_1.MikroORM, core_1.EntityManager, 'SqlEntityManager', 'MongoEntityManager'],
         };
     }
     async onApplicationShutdown() {

package/mikro-orm.common.js

@@ -6,8 +6,10 @@ const common_1 = require("@nestjs/common");
 exports.MIKRO_ORM_MODULE_OPTIONS = Symbol('mikro-orm-module-options');
 exports.REGISTERED_ENTITIES = new Set();
 exports.logger = new common_1.Logger(core_1.MikroORM.name);
-exports.getRepositoryToken = (entity) => `${core_1.Utils.className(entity)}Repository`;
-exports.InjectRepository = (entity) => common_1.Inject(exports.getRepositoryToken(entity));
+const getRepositoryToken = (entity) => `${core_1.Utils.className(entity)}Repository`;
+exports.getRepositoryToken = getRepositoryToken;
+const InjectRepository = (entity) => common_1.Inject(exports.getRepositoryToken(entity));
+exports.InjectRepository = InjectRepository;
 function UseRequestContext() {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
@@ -17,9 +19,11 @@ function UseRequestContext() {
             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 () => {
-                await originalMethod.apply(context, args);
+                result = await originalMethod.apply(context, args);
             });
+            return result;
         };
         return descriptor;
     };

package/mikro-orm.providers.d.ts

@@ -1,8 +1,9 @@
-import { AnyEntity, EntityName } from '@mikro-orm/core';
+import { AnyEntity, EntityManager, EntityName, EntityManagerType, IDatabaseDriver } from '@mikro-orm/core';
 import { MikroOrmModuleAsyncOptions } from './typings';
-import { Provider, Scope } from '@nestjs/common';
+import { Provider, Scope, Type } from '@nestjs/common';
 export declare const createMikroOrmProvider: () => Provider;
-export declare const createMikroOrmEntityManagerProvider: (scope?: Scope, alias?: string | undefined) => 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[];

package/mikro-orm.providers.js

@@ -4,7 +4,7 @@ exports.createMikroOrmRepositoryProviders = exports.createAsyncProviders = expor
 const mikro_orm_common_1 = require("./mikro-orm.common");
 const core_1 = require("@mikro-orm/core");
 const common_1 = require("@nestjs/common");
-exports.createMikroOrmProvider = () => ({
+const createMikroOrmProvider = () => ({
     provide: core_1.MikroORM,
     useFactory: async (options) => {
         if (options === null || options === void 0 ? void 0 : options.autoLoadEntities) {
@@ -22,13 +22,15 @@ exports.createMikroOrmProvider = () => ({
     },
     inject: [mikro_orm_common_1.MIKRO_ORM_MODULE_OPTIONS],
 });
-exports.createMikroOrmEntityManagerProvider = (scope = common_1.Scope.DEFAULT, alias) => ({
-    provide: alias !== null && alias !== void 0 ? alias : core_1.EntityManager,
+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.createMikroOrmAsyncOptionsProvider = (options) => {
+exports.createMikroOrmEntityManagerProvider = createMikroOrmEntityManagerProvider;
+const createMikroOrmAsyncOptionsProvider = (options) => {
     var _a;
     if (options.useFactory) {
         return {
@@ -47,7 +49,8 @@ exports.createMikroOrmAsyncOptionsProvider = (options) => {
         inject,
     };
 };
-exports.createAsyncProviders = (options) => {
+exports.createMikroOrmAsyncOptionsProvider = createMikroOrmAsyncOptionsProvider;
+const createAsyncProviders = (options) => {
     if (options.useExisting || options.useFactory) {
         return [exports.createMikroOrmAsyncOptionsProvider(options)];
     }
@@ -59,10 +62,25 @@ exports.createAsyncProviders = (options) => {
     }
     throw new Error('Invalid MikroORM async options: one of `useClass`, `useExisting` or `useFactory` should be defined.');
 };
-exports.createMikroOrmRepositoryProviders = (entities) => {
-    return (entities || []).map(entity => ({
-        provide: mikro_orm_common_1.getRepositoryToken(entity),
-        useFactory: (em) => em.getRepository(entity),
-        inject: [core_1.EntityManager],
-    }));
+exports.createAsyncProviders = createAsyncProviders;
+const createMikroOrmRepositoryProviders = (entities) => {
+    const metadata = Object.values(core_1.MetadataStorage.getMetadata());
+    const providers = [];
+    (entities || []).forEach(entity => {
+        const meta = metadata.find(meta => meta.class === entity);
+        if (meta === null || meta === void 0 ? void 0 : meta.customRepository) {
+            providers.push({
+                provide: meta.customRepository(),
+                useFactory: em => em.getRepository(entity),
+                inject: [core_1.EntityManager],
+            });
+        }
+        providers.push({
+            provide: mikro_orm_common_1.getRepositoryToken(entity),
+            useFactory: em => em.getRepository(entity),
+            inject: [core_1.EntityManager],
+        });
+    });
+    return providers;
 };
+exports.createMikroOrmRepositoryProviders = createMikroOrmRepositoryProviders;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/nestjs",
-  "version": "4.2.0",
+  "version": "4.3.1",
   "license": "MIT",
   "author": {
     "name": "Dario Mancuso",
@@ -41,26 +41,27 @@
     "lint": "eslint src/**/*.ts"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "^4.0.0-rc.6",
-    "@nestjs/common": "^7.0.0",
-    "@nestjs/core": "^7.0.0"
+    "@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"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^4.0.0-rc.6",
-    "@mikro-orm/sqlite": "^4.0.0-rc.6",
-    "@nestjs/common": "^7.4.2",
-    "@nestjs/core": "^7.4.2",
-    "@nestjs/testing": "^7.4.2",
+    "@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": "3.9.7"
+    "typescript": "4.3.5"
   },
   "jest": {
     "testTimeout": 30000,