DynamicModule

I’m submitting a…

[ ] Regression 
[ ] Bug report
[ ] Feature request
[x] Documentation issue or request
[ ] Support request => Please do not submit support request here, instead post your question on Stack Overflow.

Current behavior

DynamicModule aren’t singleton

Expected behavior

DynamicModules should be singletons

Minimal reproduction of the problem with instructions

import {Module} from "@nestjs/common";
@Module({
    imports: [ModuleC.ForRoot("A")],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleA {}

import {Module} from "@nestjs/common";
@Module({
    imports: [ModuleC.ForRoot("B")],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleB {}

import {Module} from "@nestjs/common";
@Module({
    imports: [],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleC {
    private static _Inc: number = 0;
    private static _Entities: string[] = [];
    public constructor() {
        this._test = ModuleC._Inc;
        ModuleC._Inc ++;
    }

    public static ForRoot(...entities: string[]): void {
            ModuleC._Entities = ModuleC._Entities.concat(entities);
            return {
              module: ModuleC
              providers: // createProviders somewhere using our entities
            }
    }

    public onModuleInit(): any {
        console.log(this._test);
        console.log(ModuleC._Entities);
    }
}

will output

1
[ 'A', 'B' ]
0
[ 'A', 'B' ]

I would like to have

0
['A', 'B']

================================== The workaround I found is the following

import {Module} from "@nestjs/common";

ModuleC.Configure("A");
@Module({
    imports: [ModuleC],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleA {}

import {Module} from "@nestjs/common";

ModuleC.Configure("B");
@Module({
    imports: [ModuleC],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleB {}

import {Module} from "@nestjs/common";
@Module({
    imports: [],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleC {
    private static _Inc: number = 0;
    private static _Entities: string[] = [];
    public constructor() {
        this._test = ModuleC._Inc;
        ModuleC._Inc ++;
    }

    public static Configure(...entities: string[]): void {
            ModuleC._Entities = ModuleC._Entities.concat(entities);
    }

    public onModuleInit(): any {
        console.log(this._test);
        console.log(ModuleC._Entities);
    }
}

which output

0
[ 'A', 'B' ]

but the obvious is that I can’t export any of my dynamically created providers.

What is the motivation / use case for changing the behavior?

I am creating a DatabaseModule where I want typeorm to know about all the entities that my project will have before creating it.

Environment

Nest version: 5.3.2

 
For Tooling issues:
- Node version: 10
- Platform:  Mac

Quite new to NestJS so I might have missed the obvious. Thanks!

[nolazybits]

@kamilmysliwiec the delegation works good 👍 For whoever coming here

Module A

import {Module} from "@nestjs/common";
@Module({
    imports: [ModuleC.ForRootAsync("A")],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleA {}

Module B

import {Module} from "@nestjs/common";
@Module({
    imports: [ModuleC.ForRootAsync("B")],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleB {}

Module C

import {Module} from "@nestjs/common";
@Module({
    imports: [],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleC {
    public static ForRootAsync(...entities: string[]): DynamicModule {
        return {
            module: ModuleC,
            imports: [ModuleCCore.ForRootAsync(...entities)],
        };
    }
}

Module C Core

import {Module} from "@nestjs/common";
@Module({
    imports: [],
    controllers: [],
    providers: [],
    exports: [],
})
export class ModuleCCore {
    private static _Inc: number = 0;
    private static _Entities: string[] = [];
    public constructor() {
        this._test = ModuleC._Inc;
        ModuleC._Inc ++;
    }

    public static ForRoot(...entities: string[]): void {
            ModuleCCore._Entities = ModuleCCore._Entities.concat(entities);
            return {
              module: ModuleCCore
              providers: // createProviders somewhere using our entities
            }
    }

    public onModuleInit(): any {
        console.log(this._test);
        console.log(ModuleCCore._Entities);
    }
}

and the output is then

0
[ 'A', 'B' ]

🎉

[kamilmysliwiec]

I am creating a DatabaseModule where I want typeorm to know about all the entities that my project will have before creating it.

I would suggest using another module which is shared across all dynamic modules. You could take a look at @nestjs/typeorm source code to get some inspiration how it might work underneath 🙂 https://github.com/nestjs/typeorm

In terms of the real topic of this issue, dynamic modules with different configurations AREN’T singletons and they cannot be singletons. It doesn’t make too much sense honestly.