/* * Deepkit Framework * Copyright (C) 2021 Deepkit UG, Marc J. Schmidt * * This program is free software: you can redistribute it and/or modify * it under the terms of the MIT License. * * You should have received a copy of the MIT License along with this program. */ import { AbstractClassType, ClassType, isClass, isFunction } from '@deepkit/core'; import type { InjectorModule } from './module.js'; import { ReceiveType, resolveReceiveType, Type } from '@deepkit/type'; export interface ProviderBase { /** * Per default all instances are singleton (scoped to its scope). Enabling transient makes the * Injector create always a new instance for every consumer. */ transient?: true; } /** @reflection never */ export interface ProviderScope { scope?: 'rpc' | 'http' | 'cli' | string; } /** @reflection never */ export type Token = symbol | number | bigint | boolean | string | AbstractClassType | Type | TagProvider | Function | T; export function provide( provider?: | (ProviderBase & ProviderScope & ( | { useValue?: T } | { useClass: ClassType } | { useExisting: any } | { useFactory: (...args: any[]) => T | undefined } )) | ClassType | ((...args: any[]) => T) , type?: ReceiveType, ): NormalizedProvider { if (!provider) return { provide: resolveReceiveType(type) }; if (isClass(provider)) return { provide: resolveReceiveType(type), useClass: provider }; if (isFunction(provider)) return { provide: resolveReceiveType(type), useFactory: provider }; return { ...provider, provide: resolveReceiveType(type) }; } export interface ValueProvider extends ProviderBase { /** * An injection token. */ provide: Token; /** * The value to inject. */ useValue: T; } export interface ClassProvider extends ProviderBase { /** * An injection token. */ provide: Token; /** * Class to instantiate for the `token`. */ useClass?: ClassType; } export interface ExistingProvider extends ProviderBase { /** * An injection token. */ provide: Token; /** * Existing `token` to return. (equivalent to `injector.get(useExisting)`) */ useExisting: ClassType; } export interface FactoryProvider extends ProviderBase { /** * An injection token. */ provide: Token; /** * A function to invoke to create a value for this `token`. */ useFactory: (...args: any[]) => T | undefined; } /** @reflection never */ export type Provider = AbstractClassType | ValueProvider | ClassProvider | ExistingProvider | FactoryProvider | TagProvider; /** @reflection never */ export type ProviderProvide = ValueProvider | ClassProvider | ExistingProvider | FactoryProvider; /** @reflection never */ interface TagRegistryEntry { tagProvider: TagProvider; module: InjectorModule; } /** @reflection never */ export class TagRegistry { constructor( public tags: TagRegistryEntry[] = [], ) { } register(tagProvider: TagProvider, module: InjectorModule) { return this.tags.push({ tagProvider, module }); } resolve>>(tag: T): TagRegistryEntry>[] { return this.tags.filter(v => v.tagProvider.tag instanceof tag); } } /** @reflection never */ export class TagProvider { constructor( public provider: NormalizedProvider, public tag: Tag, ) { } } /** @reflection never */ export class Tag = TagProvider> { _!: () => T; _2!: () => TP; constructor( public readonly services: T[] = [], ) { } protected createTagProvider(provider: NormalizedProvider): TP { return new TagProvider(provider, this) as TP; } static provide

| ValueProvider | ClassProvider | ExistingProvider | FactoryProvider, T extends ReturnType['_']>, TP extends ReturnType['_2']>, B extends ClassType>>(this: B, provider: P): TP { const t = new this; if (isClass(provider)) { return t.createTagProvider({ provide: provider }) as TP; } return t.createTagProvider(provider as NormalizedProvider) as TP; } } /** @reflection never */ export type NormalizedProvider = ProviderProvide & ProviderScope; /** @reflection never */ export type ProviderWithScope = AbstractClassType | (ProviderProvide & ProviderScope) | TagProvider; export function isScopedProvider(obj: any): obj is ProviderProvide & ProviderScope { return obj.provide && obj.hasOwnProperty('scope'); } export function isValueProvider(obj: any): obj is ValueProvider { return obj.provide && obj.hasOwnProperty('useValue'); } export function isClassProvider(obj: any): obj is ClassProvider { return obj.provide && !isValueProvider(obj) && !isExistingProvider(obj) && !isFactoryProvider(obj); } export function isExistingProvider(obj: any): obj is ExistingProvider { return obj.provide && obj.hasOwnProperty('useExisting'); } export function isFactoryProvider(obj: any): obj is FactoryProvider { return obj.provide && obj.hasOwnProperty('useFactory'); } export function isInjectionProvider(obj: any): obj is Provider { return isValueProvider(obj) || isClassProvider(obj) || isExistingProvider(obj) || isFactoryProvider(obj); } export function isTransient(provider: ProviderWithScope): boolean { if (isClass(provider)) return false; if (provider instanceof TagProvider) return false; return provider.transient === true; } export function getProviders( providers: ProviderWithScope[], requestScope: 'module' | 'session' | 'request' | string, ) { const result: Provider[] = []; function normalize(provider: ProviderWithScope): Provider { if (isClass(provider)) { return provider; } return provider; } for (const provider of providers) { if (isClass(provider)) { if (requestScope === 'module') result.push(provider); continue; } if (isClass(provider)) { if (requestScope === 'module') result.push(provider); continue; } const scope = isScopedProvider(provider) ? provider.scope : 'module'; if (scope === requestScope) { result.push(normalize(provider)); } } return result; }