refactor(common): Add generic to InjectionToken type

[MaurerKrisztian]

PR Checklist

Please check if your PR fulfills the following requirements:

• The commit message follows our guidelines: https://github.com/nestjs/nest/blob/master/CONTRIBUTING.md
• Tests for the changes have been added (for bug fixes / features)
• Docs have been added / updated (for bug fixes / features)

PR Type

What kind of change does this PR introduce?

• Bugfix
• Feature
• Code style update (formatting, local variables)
• Refactoring (no functional changes, no api changes)
• Build related changes
• CI related changes
• Other... Please describe:

What is the current behavior?

The InjectionToken type permits the use of any string, Type, Abstract, etc. However, it is not possible to indicate an InjectionToken Type that implements a specific interface.

Issue Number: N/A

What is the new behavior?

The new code now incorporates a generic type parameter T into the InjectionToken. This addition is particularly useful for creating dynamic modules that require an InjectionToken provider token.
Without this generic type, the code would be less robust in terms of type safety.
Fortunately, this change maintains compatibility with the previous behavior.

Does this PR introduce a breaking change?

• Yes
• No

Other information

[coveralls]

Pull Request Test Coverage Report for Build 5aed9202-f4a6-47ab-a0e2-d7d85f50e81b

• 0 of 0 changed or added relevant lines in 0 files are covered.
• No unchanged relevant lines lost coverage.
• Overall coverage remained the same at 92.675%

---

Totals
Change from base Build 8e8f7ddd-90d9-49bd-a8f9-0d8b865d99bf:	0.0%
Covered Lines:	6516
Relevant Lines:	7031

---

💛 - Coveralls

[jmcdo29]

Could you show how the generic will help here?

[MaurerKrisztian]

Sure! Here's a simplified use case for the generic.
Imagine you have a dynamic module that requires an InjectionToken parameter and the useFactory will resolve it.

export interface IProvider {
    provide(context: string): unknown;
}

@Module({})
export class ExampleModule implements NestModule {
    static forRootAsync(options: { customProvider: InjectionToken<IProvider> }): DynamicModule {
        return {
            module: ExampleModule,
            imports: [],
            providers: [
                {
                    provide: 'Key', // this is used in this module to do some things..
                    useFactory: (provider: IProvider, context: string) => {
                        // the module will provide the context..
                        const result = provider.provide(context);
                        // ...
                    	return result;
                    },
                    inject: [options.customProvider, 'context'],
                },
                {
                    provide: 'context',
                    useValue: 'world!',
                },
            ],
            exports: [],
        };
    }

    configure(consumer: MiddlewareConsumer): void {}
}

the module user perspective:

export class ExampleProvider implements IProvider {
    // the context is provided by the module
    provide(context: string): unknown {
        return `Hello ${context}`;
    }
}

App module imports:

    ExampleModule.forRootAsync({ customProvider: ExampleProvider }),

    or

    ExampleModule.forRootAsync({ customProvider: 'ProviderKey' }),

This customProvider must implement the IProvider interface because the module uses it.

[kamilmysliwiec]

lgtm