MikroOrm - MikroORM and EntityManager from driver specific packages

[xmajzel]

When registering MikroOrmModule using forRootAsync together with useFactory function, which contains at least one injection parameter, only MikroORM and EntityManager are registered only from '@mikro-orm/core' package.

...
MikroOrmModule.forRootAsync({
  useFactory: (configService: ConfigService) => configService.getOrThrow(ConfigKey.ORM),
  inject: [ConfigService],
})
...

I think there is no way, how this could be done automatically in MikroOrmModule.forRootAsync in that case, but I came up with very simple solution - create alias module, which can user register manually:

E.g.: mikro-orm-alias.module.ts for '@mikro-orm/postgresql' specific driver

import { type DynamicModule, Module, Global } from '@nestjs/common'
import { MikroORM as PostgreSqlMikroORM, EntityManager as SqlEntityManager } from '@mikro-orm/postgresql'
import { MikroORM, EntityManager } from '@mikro-orm/core'

@Global()
@Module({})
export class MikroOrmAliasModule {
  static forRoot(): DynamicModule {
    return {
      module: MikroOrmAliasModule,
      providers: [
        {
          provide: PostgreSqlMikroORM,
          useFactory: (mikroOrm: MikroORM) => mikroOrm,
          inject: [MikroORM],
        },
        {
          provide: SqlEntityManager,
          useFactory: (entityManager: EntityManager) => entityManager,
          inject: [EntityManager],
        },
      ],
      exports: [PostgreSqlMikroORM, SqlEntityManager],
    }
  }
}

And than using in Root module:

...
MikroOrmAliasModule.forRoot(),
...

Than driver specific injection in services works fine:

import { RequestContext, MikroORM } from '@mikro-orm/postgresql'
...
constructor(private readonly orm: MikroOrm) {}
...

---

I am thinking about, if it probably could be somehow embedded into MikroOrm, so user imports and registers driver specific alias module, so driver specific injection will work.

Or probably it could be mentioned somewhere in documentation?

[B4nan]

I am not sure how could we integrate this (unless we provide driver specific exports in the nest package too), but this is surely worth documenting.

[xmajzel]

Yup, probably driver specific export would be an overkill for the nest package 😄

[B4nan]

Maybe we could at least simplify this - all we need to know is the driver in use, from there we can infer everything. So instead of wrapping everything explicitly, we could just let the user pass in the driver in a separate option next to the useFactory, something like this:

MikroOrmModule.forRootAsync({
  useFactory: (configService: ConfigService) => configService.getOrThrow(ConfigKey.ORM),
  inject: [ConfigService],
  driver: PostgreSqlDriver,
})

Then we can create the driver instance and the EM out of it. I also wanted to add public methods to the platform level to expose the MikroORM class variants so they could be easily extracted from there.

[xmajzel]

For the user, adding such a parameter could be quite simple, as well as the implementation itself. I'm definitely in favor.

[rubiin]

does this mean we cannot use .forRootAsync

[B4nan]

This opening post shows how you can get around the problem.

[rubiin]

mikro-orm-alias.module.ts would only work for forRoot. If thats the case I would not be able to use config service for getting the configs

[xmajzel]

The post contains all information, but I will try to explain it to you briefly.

You can use forRootAsync as follows:

...
MikroOrmModule.forRootAsync({
  useFactory: (configService: ConfigService) => configService.getOrThrow(ConfigKey.ORM),
  inject: [ConfigService],
})
...

But when injecting MikroOrm or EntityManager in Nest you would have to do it like follows:

import { MikroORM } from '@mikro-orm/core'
...
constructor(private readonly orm: MikroORM) {}
...

!Note: See the import, you are importing MikroORM from (@mikro-orm/core), because there is no way currently for mikro to dynamically know you are using e.g. PostgreSqlDriver when using forRootAsync. If you would like to have it typed correctly, you can use:

import { MikroORM } from '@mikro-orm/core'
+import { PostgreSqlDriver } from '@mikro-orm/postgresql'
...
-constructor(private readonly orm: MikroORM) {}
+constructor(private readonly orm: MikroORM<PostgreSqlDriver>) {}
...

But if you want your code to have more clean and use only imports from driver specific package, e.g. @mikro-orm/postgresql, you can just take code from the post - mikro-orm-alias.module.ts (if you are using other driver than postgresql update it accordingly) and register it using:

...
MikroOrmAliasModule.forRoot(),
...

Than you would be able to use:

import { MikroORM } from '@mikro-orm/postgresql'
...
constructor(private readonly orm: MikroORM) {}
...

!Note: See the import, you are importing MikroORM from (@mikro-orm/postgresql), meaning your orm property is typed with driver specific type without unnecessary imports.

[rubiin]

let me test it out. Thanks for the reply :)