feat(injector): add support for receive type in isProvided (#511)

* feat(injector): resolve receive type in isProvided

* chore: remove unnecessary code

* refactor(injector): improve isProvided function

---------

Signed-off-by: Marcus S. Abildskov <[email protected]>

Author: marcus-sa

packages/app/src/service-container.ts

@@ -11,11 +11,21 @@
 import { ClassType, getClassName, isClass, isFunction } from '@deepkit/core';
 import { EventDispatcher, EventListenerRegistered, isEventListenerContainerEntryCallback } from '@deepkit/event';
 import { AddedListener, AppModule, ConfigurationInvalidError, MiddlewareConfig, ModuleDefinition } from './module.js';
-import { injectedFunction, Injector, InjectorContext, InjectorModule, isProvided, ProviderWithScope, resolveToken, Token } from '@deepkit/injector';
+import {
+    injectedFunction,
+    Injector,
+    InjectorContext,
+    InjectorModule,
+    isProvided,
+    provide,
+    ProviderWithScope,
+    resolveToken,
+    Token
+} from '@deepkit/injector';
 import { cli } from './command.js';
 import { WorkflowDefinition } from '@deepkit/workflow';
 import { deserialize, ReflectionClass, ReflectionFunction, validate } from '@deepkit/type';
-import { ConsoleTransport, Logger, ScopedLogger } from '@deepkit/logger';
+import { ConsoleTransport, Logger, LoggerInterface, ScopedLogger } from '@deepkit/logger';
 
 export interface ControllerConfig {
     controller?: ClassType,

packages/injector/src/injector.ts

@@ -184,13 +184,15 @@ export function resolveToken(provider: ProviderWithScope): Token {
     return provider.provide;
 }
 
+export type ContainerToken = Exclude<Token, Type | TagProvider<any>>;
+
 /**
  * Returns a value that can be compared with `===` to check if two tokens are actually equal even though
  * they are the result of different type expressions.
  *
  * This is used in the big switch-case statement in the generated code to match DI tokens.
  */
-export function getContainerToken(type: Token): string | number | symbol | bigint | boolean | RegExp | ClassType | Function {
+export function getContainerToken(type: Token): ContainerToken {
     if (isClass(type)) return type;
     if (type instanceof TagProvider) return getContainerToken(type.provider);
 

packages/injector/src/module.ts

@@ -1,14 +1,14 @@
 import { NormalizedProvider, ProviderWithScope, TagProvider, Token } from './provider.js';
 import { arrayRemoveItem, ClassType, getClassName, isClass, isPlainObject, isPrototypeOfBase } from '@deepkit/core';
-import { BuildContext, Injector, SetupProviderRegistry } from './injector.js';
+import { BuildContext, getContainerToken, Injector, resolveToken, SetupProviderRegistry } from './injector.js';
 import {
     hasTypeInformation,
     isType,
     ReceiveType,
     reflect,
     ReflectionKind,
     reflectOrUndefined,
-    resolveReceiveType, stringifyType,
+    resolveReceiveType,
     Type,
     TypeClass,
     typeInfer,
@@ -226,8 +226,9 @@ export function findModuleForConfig(config: ClassType, modules: InjectorModule[]
 
 export type ExportType = Token | InjectorModule;
 
-export function isProvided(providers: ProviderWithScope[], token: any): boolean {
-    return providers.find(v => !(v instanceof TagProvider) ? token === (isClass(v) ? v : v.provide) : false) !== undefined;
+
+export function isProvided<T>(providers: ProviderWithScope[], token: Token<T>): boolean {
+    return providers.some(v => getContainerToken(resolveToken(v)) === getContainerToken(token));
 }
 
 export function getScope(provider: ProviderWithScope): string {
@@ -342,8 +343,11 @@ export class InjectorModule<C extends { [name: string]: any } = any, IMPORT = In
         return this.exports.includes(token);
     }
 
-    isProvided(classType: ClassType): boolean {
-        return isProvided(this.getProviders(), classType);
+    isProvided<T>(token?: Token<T>, type?: ReceiveType<T>): boolean {
+        if (!token) {
+            token = resolveReceiveType(type);
+        }
+        return isProvided<T>(this.getProviders(), token);
     }
 
     addProvider(...provider: (ProviderWithScope | ProviderWithScope[])[]): this {

packages/injector/src/provider.ts

@@ -25,7 +25,7 @@ export interface ProviderScope {
 }
 
 /** @reflection never */
-export type Token<T = any> = symbol | number | bigint | RegExp | boolean | string | AbstractClassType<T> | Type | T;
+export type Token<T = any> = symbol | number | bigint | RegExp | boolean | string | AbstractClassType<T> | Type | TagProvider<T> | Function | T;
 
 export function provide<T>(
     provider:
@@ -95,7 +95,7 @@ export interface FactoryProvider<T> extends ProviderBase {
 }
 
 /** @reflection never */
-export type Provider<T = any> = ClassType | ValueProvider<T> | ClassProvider<T> | ExistingProvider<T> | FactoryProvider<T> | TagProvider<T>;
+export type Provider<T = any> = AbstractClassType | ValueProvider<T> | ClassProvider<T> | ExistingProvider<T> | FactoryProvider<T> | TagProvider<T>;
 
 /** @reflection never */
 export type ProviderProvide<T = any> = ValueProvider<T> | ClassProvider<T> | ExistingProvider<T> | FactoryProvider<T>;
@@ -163,7 +163,7 @@ export class Tag<T, TP extends TagProvider<T> = TagProvider<T>> {
 export type NormalizedProvider<T = any> = ProviderProvide<T> & ProviderScope;
 
 /** @reflection never */
-export type ProviderWithScope<T = any> = ClassType | (ProviderProvide<T> & ProviderScope) | TagProvider<any>;
+export type ProviderWithScope<T = any> = AbstractClassType | (ProviderProvide<T> & ProviderScope) | TagProvider<any>;
 
 export function isScopedProvider(obj: any): obj is ProviderProvide & ProviderScope {
     return obj.provide && obj.hasOwnProperty('scope');

packages/injector/tests/injector.spec.ts

@@ -9,7 +9,7 @@ import {
     PartialFactory,
 } from '../src/injector.js';
 import { InjectorModule } from '../src/module.js';
-import { ReflectionClass, ReflectionKind, ReflectionParameter, ReflectionProperty } from '@deepkit/type';
+import { ReflectionClass, ReflectionKind } from '@deepkit/type';
 import { Inject } from '../src/types.js';
 import { provide } from '../src/provider.js';
 
@@ -1025,3 +1025,19 @@ test('PartialFactory', () => {
         expect(a.num).toBe(5);
     }
 });
+
+test('isProvided supports receive type', () => {
+    interface A {
+        b: string;
+    }
+    const providers = [provide<A>({ useValue: { b: 'a' } })];
+    const module = new InjectorModule(providers)
+    expect(module.isProvided<A>()).toBe(true);
+});
+
+test('isProvided supports token', () => {
+    class A {}
+    const providers = [A];
+    const module = new InjectorModule(providers)
+    expect(module.isProvided(A)).toBe(true);
+});