@tsed/di 8.11.1 → 8.11.2-rc.1

package/src/common/fn/inject.spec.ts

@@ -1,54 +0,0 @@
-import {DITest} from "../../node/index.js";
-import {Injectable} from "../decorators/injectable.js";
-import {InjectorService} from "../services/InjectorService.js";
-import {inject} from "./inject.js";
-
-@Injectable()
-class ProvidersList extends Map<string, string> {}
-
-@Injectable()
-class MyService {
-  readonly providersList = inject(ProvidersList);
-
-  getValue() {
-    return this.providersList.get("key");
-  }
-}
-
-describe("inject()", () => {
-  beforeEach(() => DITest.create());
-  afterEach(() => DITest.reset());
-
-  it("should inject the expected provider", async () => {
-    class Nested {}
-
-    class Test {
-      readonly injector = inject(InjectorService);
-      readonly nested = inject(Nested);
-
-      constructor() {
-        expect(this.injector).toBeInstanceOf(InjectorService);
-        expect(this.nested).not.toBeInstanceOf(Nested);
-      }
-    }
-
-    await DITest.invoke(Test, [
-      {
-        token: Nested,
-        use: {}
-      }
-    ]);
-  });
-  it("should rebuild all dependencies using invoke", async () => {
-    const providersList = inject(ProvidersList);
-    const myService = inject(MyService);
-    providersList.set("key", "value");
-
-    expect(inject(ProvidersList).get("key")).toEqual("value");
-    expect(myService.getValue()).toEqual("value");
-
-    const newMyService = await DITest.invoke(MyService, []);
-    expect(newMyService.getValue()).toEqual(undefined);
-    expect(myService.getValue()).toEqual("value");
-  });
-});

package/src/common/fn/inject.ts

@@ -1,32 +0,0 @@
-import type {InvokeOptions} from "../interfaces/InvokeOptions.js";
-import type {TokenProvider} from "../interfaces/TokenProvider.js";
-import {injector} from "./injector.js";
-import {invokeOptions, localsContainer} from "./localsContainer.js";
-
-/**
- * Inject a provider to another provider.
- *
- * Use this function to inject a custom provider on constructor parameter or property.
- *
- * ```typescript
- * @Injectable()
- * export class MyService {
- *   connection = inject(CONNECTION);
- * }
- * ```
- *
- * @param token A token provider or token provider group
- * @param opts
- * @returns {Function}
- * @decorator
- */
-export function inject<TokenType>(
-  token: TokenProvider<TokenType>,
-  opts?: Partial<Pick<InvokeOptions, "useOpts" | "rebuild" | "locals">>
-): TokenType {
-  return injector().resolve(token, {
-    ...opts,
-    ...invokeOptions(),
-    locals: opts?.locals || localsContainer()
-  });
-}

package/src/common/fn/injectMany.ts

@@ -1,16 +0,0 @@
-import type {InvokeOptions} from "../interfaces/InvokeOptions.js";
-import {injector} from "./injector.js";
-import {localsContainer} from "./localsContainer.js";
-
-/**
- * Injects multiple instances of a given token using the injector service.
- * @param token - The injection token to resolve
- * @param opts - Optional configuration for the injection
- * @param opts.useOpts - Options for instance creation
- * @param opts.rebuild - Whether to rebuild the instance
- * @param opts.locals - Local container overrides
- * @returns Array of resolved instances
- */
-export function injectMany<T>(token: string | symbol, opts?: Partial<Pick<InvokeOptions, "useOpts" | "rebuild" | "locals">>): T[] {
-  return injector().getMany<T>(token, {...opts, locals: opts?.locals || localsContainer()} as InvokeOptions);
-}

package/src/common/fn/injectable.spec.ts

@@ -1,88 +0,0 @@
-import {Store} from "@tsed/core";
-
-import {DITest} from "../../node/index.js";
-import {ProviderScope} from "../domain/ProviderScope.js";
-import {ProviderType} from "../domain/ProviderType.js";
-import {inject} from "./inject.js";
-import {controller, injectable, interceptor} from "./injectable.js";
-import {logger} from "./logger.js";
-
-class Nested {
-  get() {
-    return "hello";
-  }
-}
-
-class MyClass {
-  nested = inject(Nested);
-  logger = logger();
-}
-
-class MyController {}
-
-injectable(Nested).scope(ProviderScope.SINGLETON).class(Nested);
-injectable(MyClass);
-
-describe("injectable", () => {
-  describe("injectable()", () => {
-    it("should define a singleton scope", async () => {
-      const instance = await DITest.invoke(MyClass);
-
-      expect(instance.nested).toBeInstanceOf(Nested);
-      expect(instance.nested.get()).toEqual("hello");
-    });
-    it("should define class with scope", async () => {
-      injectable(MyClass).scope(ProviderScope.SINGLETON).class(MyClass).store().set("test", "test");
-
-      expect(Store.from(MyClass).get("test")).toEqual("test");
-    });
-    it("should create a factory", async () => {
-      const builder = injectable(Symbol.for("Test")).factory(() => "test");
-      const provider = builder.inspect();
-
-      expect(provider.type).toEqual(ProviderType.PROVIDER);
-      expect(builder.token()).toEqual(Symbol.for("Test"));
-    });
-    it("should create an async factory", async () => {
-      const builder = injectable(Symbol.for("Test")).asyncFactory(() => Promise.resolve("test"));
-      const provider = builder.inspect();
-
-      expect(provider.type).toEqual(ProviderType.PROVIDER);
-      expect(builder.token()).toEqual(Symbol.for("Test"));
-    });
-    it("should create a value", async () => {
-      const builder = injectable(Symbol.for("Test")).value({
-        test: "test"
-      });
-      const provider = builder.inspect();
-
-      expect(provider.type).toEqual(ProviderType.VALUE);
-      expect(builder.token()).toEqual(Symbol.for("Test"));
-    });
-  });
-
-  describe("controller()", () => {
-    it("should define a singleton scope", async () => {
-      const builder = controller(MyController)
-        .path("/my-controller")
-        .scope(ProviderScope.REQUEST)
-        .middlewares({
-          use: [() => {}]
-        });
-
-      const provider = builder.inspect();
-
-      expect(provider.type).toEqual(ProviderType.CONTROLLER);
-      expect(provider.scope).toEqual(ProviderScope.REQUEST);
-    });
-  });
-
-  describe("interceptor()", () => {
-    it("should define a singleton scope", async () => {
-      const builder = interceptor(MyController);
-      const provider = builder.inspect();
-
-      expect(provider.type).toEqual(ProviderType.INTERCEPTOR);
-    });
-  });
-});

package/src/common/fn/injectable.ts

@@ -1,15 +0,0 @@
-import {ControllerProvider} from "../domain/ControllerProvider.js";
-import type {Provider} from "../domain/Provider.js";
-import {ProviderType} from "../domain/ProviderType.js";
-import {providerBuilder} from "../utils/providerBuilder.js";
-
-type PickedProps = "scope" | "path" | "alias" | "hooks" | "deps" | "imports" | "configuration" | "priority";
-
-const Props = ["type", "scope", "path", "alias", "hooks", "deps", "imports", "configuration", "priority"];
-export const injectable = providerBuilder<Provider, PickedProps | "type">(Props);
-export const interceptor = providerBuilder<Provider, PickedProps | "type">(Props, {
-  type: ProviderType.INTERCEPTOR
-});
-export const controller = providerBuilder<ControllerProvider, PickedProps | "children" | "middlewares">([...Props, "middlewares"], {
-  type: ProviderType.CONTROLLER
-});

package/src/common/fn/injector.ts

@@ -1,26 +0,0 @@
-import {InjectorService} from "../services/InjectorService.js";
-
-let globalInjector: InjectorService = new InjectorService();
-
-/**
- * Return the existing injector service.
- *
- * Example:
- *
- * ```typescript
- * import {injector, Injectable} from "@tsed/di";
- *
- * @Injectable()
- * class MyService {
- *   injector = injector();
- * }
- * ```
- */
-export function injector(): InjectorService {
-  return globalInjector;
-}
-
-export async function destroyInjector() {
-  await globalInjector.destroy();
-  globalInjector = new InjectorService();
-}

package/src/common/fn/lazyInject.spec.ts

@@ -1,22 +0,0 @@
-import {afterEach, beforeEach} from "vitest";
-
-import {DITest} from "../../node/index.js";
-import {lazyInject, optionalLazyInject} from "./lazyInject.js";
-
-describe("lazyInject", () => {
-  beforeEach(() => DITest.create());
-  afterEach(() => DITest.reset());
-
-  it("should lazy load module", async () => {
-    const service = await lazyInject(() => import("./__mock__/lazy.import.module.js"));
-
-    expect(service).toBeDefined();
-    expect(service.called).toBeTruthy();
-  });
-
-  it("should optionally lazy load module", async () => {
-    const service = await optionalLazyInject(() => import("./__mock__/lazy.import.module.js"));
-
-    expect(service).toBeDefined();
-  });
-});

package/src/common/fn/lazyInject.ts

@@ -1,36 +0,0 @@
-import {isFunction} from "@tsed/core/utils/isFunction.js";
-
-import type {TokenProvider} from "../interfaces/TokenProvider.js";
-import {inject} from "./inject.js";
-import {injector} from "./injector.js";
-
-/**
- * Lazy load a provider from his package and invoke only when the provider is used.
- */
-export async function lazyInject<Token>(factory: () => Promise<{default: TokenProvider<Token>}>): Promise<Token> {
-  const {default: token} = await factory();
-
-  if (!injector().has(token)) {
-    const instance = await inject(token);
-
-    const instanceWithHook = instance as unknown as {$onInit?: () => Promise<void>};
-
-    if ("$onInit" in instanceWithHook && isFunction(instanceWithHook.$onInit)) {
-      await instanceWithHook.$onInit();
-    }
-  }
-
-  return injector().get(token) as unknown as Promise<Token>;
-}
-
-export async function optionalLazyInject<Token>(
-  factory: () => Promise<{
-    default: TokenProvider;
-  }>
-): Promise<Token | undefined> {
-  try {
-    return await lazyInject(factory);
-  } catch (er) {
-    return undefined;
-  }
-}

package/src/common/fn/localsContainer.ts

@@ -1,55 +0,0 @@
-import {LocalsContainer} from "../domain/LocalsContainer.js";
-import type {UseImportTokenProviderOpts} from "../interfaces/ImportTokenProviderOpts.js";
-import {InjectorService} from "../services/InjectorService.js";
-import {injector} from "./injector.js";
-
-let globalLocals: LocalsContainer | undefined;
-let globalInvOpts: any = {};
-const stagedLocals: LocalsContainer[] = [];
-
-/**
- * Get the locals container initiated by DITest or .bootstrap() method.
- */
-export function localsContainer({
-  providers,
-  rebuild
-}: {
-  providers?: UseImportTokenProviderOpts[];
-  rebuild?: boolean;
-} = {}) {
-  if (!globalLocals || providers) {
-    globalLocals = new LocalsContainer();
-
-    if (providers) {
-      providers.forEach((p) => {
-        globalLocals!.set(p.token, p.use);
-      });
-
-      globalLocals.set(InjectorService, injector());
-    }
-
-    if (rebuild) {
-      globalInvOpts.rebuild = rebuild;
-    }
-  }
-
-  return globalLocals;
-}
-
-export function invokeOptions() {
-  return {...globalInvOpts};
-}
-
-/**
- * Reset the locals container.
- */
-export function detachLocalsContainer() {
-  globalLocals && stagedLocals.push(globalLocals);
-  globalLocals = undefined;
-  globalInvOpts = {};
-}
-
-export function cleanAllLocalsContainer() {
-  detachLocalsContainer();
-  stagedLocals.map((item) => item.clear());
-}

package/src/common/fn/logger.ts

@@ -1,8 +0,0 @@
-import {injector} from "./injector.js";
-
-/**
- * Get the current `injector.logger` instance.
- */
-export function logger() {
-  return injector().logger;
-}

package/src/common/fn/refValue.spec.ts

@@ -1,47 +0,0 @@
-import {DITest} from "../../node/index.js";
-import {configuration} from "./configuration.js";
-import {refValue} from "./refValue.js";
-
-describe("refValue()", () => {
-  beforeEach(() =>
-    DITest.create({
-      logger: {
-        level: "off"
-      }
-    })
-  );
-  afterEach(() => DITest.reset());
-  describe("when decorator is used as property decorator", () => {
-    it("should create a getter", async () => {
-      // WHEN
-      class Test {
-        test = refValue("logger.level", "default value");
-      }
-
-      // THEN
-
-      const test = await DITest.invoke<Test>(Test);
-
-      expect(test.test.value).toEqual("off");
-
-      test.test.value = "test";
-
-      expect(test.test.value).toEqual("test");
-    });
-    it("should create a getter with default value", async () => {
-      expect(configuration().get("logger.test")).toEqual(undefined);
-
-      // WHEN
-      class Test {
-        test = refValue("logger.test", "default value");
-      }
-
-      // THEN
-
-      const test = await DITest.invoke<Test>(Test);
-
-      expect(test.test.value).toEqual("default value");
-      expect(configuration().get("logger.test")).toEqual(undefined);
-    });
-  });
-});

package/src/common/fn/refValue.ts

@@ -1,33 +0,0 @@
-import {injector} from "./injector.js";
-
-/**
- * Get a value from the `injector.settings`.
- *
- * ## Example
- *
- * ```ts
- * import {refValue, Injectable} from "@tsed/di";
- *
- * @Injectable()
- * class Test {
- *   test = refValue("logger.level", "default value");
- *
- *   constructor() {
- *     console.log(this.test.value); // "off"
- *   }
- * }
- *
- * @param expression The expression to get the value from the `injector.settings`.
- */
-export function refValue<Type>(expression: string): {value: Type | undefined};
-export function refValue<Type>(expression: string, defaultValue: Type | undefined): {value: Type};
-export function refValue<Type>(expression: string, defaultValue?: Type | undefined): {value: Type | undefined} {
-  return Object.freeze({
-    get value() {
-      return injector().settings.get(expression, defaultValue);
-    },
-    set value(value: Type) {
-      injector().settings.set(expression, value);
-    }
-  });
-}

package/src/common/index.ts

@@ -1,64 +0,0 @@
-/**
- * @file Automatically generated by @tsed/barrels.
- */
-export * from "./constants/constants.js";
-export * from "./decorators/autoInjectable.js";
-export * from "./decorators/configuration.js";
-export * from "./decorators/constant.js";
-export * from "./decorators/controller.js";
-export * from "./decorators/inject.js";
-export * from "./decorators/injectable.js";
-export * from "./decorators/intercept.js";
-export * from "./decorators/interceptor.js";
-export * from "./decorators/lazyInject.js";
-export * from "./decorators/module.js";
-export * from "./decorators/opts.js";
-export * from "./decorators/overrideProvider.js";
-export * from "./decorators/scope.js";
-export * from "./decorators/service.js";
-export * from "./decorators/useOpts.js";
-export * from "./decorators/value.js";
-export * from "./domain/Container.js";
-export * from "./domain/ControllerProvider.js";
-export * from "./domain/InjectablePropertyType.js";
-export * from "./domain/LocalsContainer.js";
-export * from "./domain/Provider.js";
-export * from "./domain/ProviderScope.js";
-export * from "./domain/ProviderType.js";
-export * from "./errors/InjectionError.js";
-export * from "./errors/InvalidPropertyTokenError.js";
-export * from "./fn/configuration.js";
-export * from "./fn/constant.js";
-export * from "./fn/inject.js";
-export * from "./fn/injectable.js";
-export * from "./fn/injectMany.js";
-export * from "./fn/injector.js";
-export * from "./fn/lazyInject.js";
-export * from "./fn/localsContainer.js";
-export * from "./fn/logger.js";
-export * from "./fn/refValue.js";
-export * from "./interfaces/DIConfigurationOptions.js";
-export * from "./interfaces/DILogger.js";
-export * from "./interfaces/DILoggerOptions.js";
-export * from "./interfaces/ImportTokenProviderOpts.js";
-export * from "./interfaces/InterceptorContext.js";
-export * from "./interfaces/InterceptorMethods.js";
-export * from "./interfaces/InvokeOptions.js";
-export * from "./interfaces/OnDestroy.js";
-export * from "./interfaces/OnInit.js";
-export * from "./interfaces/ProviderOpts.js";
-export * from "./interfaces/RegistrySettings.js";
-export * from "./interfaces/ResolvedInvokeOptions.js";
-export * from "./interfaces/TokenProvider.js";
-export * from "./interfaces/TokenRoute.js";
-export * from "./registries/GlobalProviders.js";
-export * from "./registries/ProviderRegistry.js";
-export * from "./services/DIConfiguration.js";
-export * from "./services/DILogger.js";
-export * from "./services/InjectorService.js";
-export * from "./utils/colors.js";
-export * from "./utils/createContainer.js";
-export * from "./utils/discoverHooks.js";
-export * from "./utils/getConfiguration.js";
-export * from "./utils/getConstructorDependencies.js";
-export * from "./utils/providerBuilder.js";

package/src/common/integration/async-factory.spec.ts

@@ -1,60 +0,0 @@
-import {isPromise} from "@tsed/core";
-import {afterEach, beforeEach} from "vitest";
-
-import {Inject} from "../decorators/inject.js";
-import {Injectable} from "../decorators/injectable.js";
-import {Container} from "../domain/Container.js";
-import {destroyInjector, injector} from "../fn/injector.js";
-import {GlobalProviders} from "../registries/GlobalProviders.js";
-import {registerProvider} from "../registries/ProviderRegistry.js";
-import {InjectorService} from "../services/InjectorService.js";
-
-describe("DI", () => {
-  afterEach(() => destroyInjector());
-  describe("create new injector", () => {
-    const ASYNC_FACTORY = Symbol.for("ASYNC_FACTORY");
-
-    registerProvider({
-      token: ASYNC_FACTORY,
-
-      useAsyncFactory() {
-        return {
-          connection: true,
-          close() {}
-        };
-      },
-      hooks: {
-        $onDestroy(instance: any) {
-          return instance.close();
-        }
-      }
-    });
-
-    @Injectable()
-    class Server {
-      @Inject(ASYNC_FACTORY)
-      asyncFactory: any;
-    }
-
-    afterAll(() => {
-      GlobalProviders.delete(Server);
-      GlobalProviders.delete(ASYNC_FACTORY);
-    });
-
-    it("should load all providers with the SINGLETON scope only", async () => {
-      // GIVEN
-      const container = new Container();
-      container.add(ASYNC_FACTORY);
-      container.add(Server);
-
-      const server = injector().invoke<any>(Server);
-      expect(isPromise(server.asyncFactory)).toEqual(true);
-
-      // WHEN
-      await injector().load(container);
-
-      expect(isPromise(server.asyncFactory)).toEqual(false);
-      expect(server.asyncFactory.connection).toEqual(true);
-    });
-  });
-});