@tsed/di 8.11.0 → 8.11.2-rc.1

package/src/node/services/DITest.spec.ts

@@ -1,109 +0,0 @@
-import {Inject, Injectable, injectable, InjectorService} from "../../index.js";
-import {DITest} from "../services/DITest.js";
-
-class Model {}
-
-const SQLITE_DATA_SOURCE = injectable(Symbol.for("SQLITE_DATA_SOURCE"))
-  .type("typeorm:datasource")
-  .asyncFactory(() => {
-    return Promise.resolve({
-      id: "sqlite"
-    });
-  })
-  .token();
-
-export abstract class AbstractDao {
-  private readonly dao: any;
-
-  protected constructor(
-    protected readonly ds: any,
-    model: any
-  ) {
-    this.dao = ds.getRepository(model);
-  }
-
-  getRepository(transaction?: any): any {
-    return transaction ? transaction.getRepository(this.dao.target) : this.dao;
-  }
-}
-
-@Injectable()
-export class FileDao extends AbstractDao {
-  public constructor(@Inject(SQLITE_DATA_SOURCE) protected ds: any) {
-    super(ds, Model);
-  }
-}
-
-describe("DITest", () => {
-  describe("create()", () => {
-    beforeEach(() =>
-      DITest.create({
-        imports: [
-          {
-            token: SQLITE_DATA_SOURCE,
-            use: {
-              initialize: vi.fn(),
-              getRepository: vi.fn().mockReturnValue({
-                repository: true
-              })
-            }
-          },
-          {
-            token: InjectorService, // not possible to override the injector
-            use: "test"
-          }
-        ]
-      })
-    );
-    afterEach(() => DITest.reset());
-
-    it("should return a service with pre mocked dependencies", () => {
-      const service = DITest.get<FileDao>(FileDao);
-      const repository = DITest.get(SQLITE_DATA_SOURCE);
-
-      expect(repository.getRepository).toHaveBeenCalledWith(Model);
-
-      const result = service.getRepository();
-
-      expect(result).toEqual({
-        repository: true
-      });
-    });
-
-    it("should return a service with pre mocked dependencies (invoke)", async () => {
-      const service = await DITest.invoke<FileDao>(FileDao);
-
-      const repository = DITest.get(SQLITE_DATA_SOURCE);
-
-      expect(repository.getRepository).toHaveBeenCalledWith(Model);
-
-      const result = service.getRepository();
-
-      expect(result).toEqual({
-        repository: true
-      });
-    });
-
-    it("should return a service with pre mocked dependencies (invoke + mock)", async () => {
-      const dao = {
-        initialize: vi.fn(),
-        getRepository: vi.fn().mockReturnValue({
-          repository: false
-        })
-      };
-      const service = await DITest.invoke<FileDao>(FileDao, [
-        {
-          token: SQLITE_DATA_SOURCE,
-          use: dao
-        }
-      ]);
-
-      const result = service.getRepository();
-
-      expect(dao.getRepository).toHaveBeenCalledWith(Model);
-      expect(result).toEqual({
-        repository: false
-      });
-    });
-  });
-});

package/src/node/services/DITest.ts

@@ -1,122 +0,0 @@
-import {Env} from "@tsed/core/types/Env.js";
-import {getValue} from "@tsed/core/utils/getValue.js";
-import {isClass} from "@tsed/core/utils/isClass.js";
-import {isObject} from "@tsed/core/utils/isObject.js";
-import {$log} from "@tsed/logger";
-
-import {cleanAllLocalsContainer, detachLocalsContainer, localsContainer} from "../../common/fn/localsContainer.js";
-import {logger} from "../../common/fn/logger.js";
-import {
-  createContainer,
-  destroyInjector,
-  DI_INJECTABLE_PROPS,
-  inject,
-  injector,
-  InjectorService,
-  type OnInit,
-  TokenProvider,
-  type UseImportTokenProviderOpts
-} from "../../common/index.js";
-import {DIContext} from "../domain/DIContext.js";
-import {setLoggerConfiguration} from "../utils/setLoggerConfiguration.js";
-
-/**
- * Tool to run test with lightweight DI sandbox.
- */
-export class DITest {
-  static get injector() {
-    return injector();
-  }
-
-  static async create(settings: Partial<TsED.Configuration> = {}) {
-    DITest.createInjector(settings);
-    await DITest.createContainer();
-  }
-
-  static async createContainer() {
-    await injector().load(createContainer());
-  }
-
-  /**
-   * Create a new injector with the right default services
-   */
-  static createInjector(settings: any = {}): InjectorService {
-    const inj = injector();
-    injector().logger = $log;
-    inj.settings.set(DITest.configure(settings));
-
-    setLoggerConfiguration();
-
-    return inj;
-  }
-
-  /**
-   * Resets the test injector of the test context, so it won't pollute your next test. Call this in your `tearDown` logic.
-   */
-  static async reset() {
-    await destroyInjector();
-    cleanAllLocalsContainer();
-  }
-
-  /**
-   * Invoke a provider and return a fresh instance
-   * @param target
-   * @param providers
-   */
-  static async invoke<T = any>(target: TokenProvider<T>, providers: UseImportTokenProviderOpts[] = []): Promise<T> {
-    const locals = localsContainer({providers, rebuild: true});
-
-    const instance: T & Partial<OnInit> = inject(target as any, {locals, rebuild: true});
-
-    if (instance && isObject(instance) && instance?.$onInit) {
-      const result = instance.$onInit();
-
-      if (result instanceof Promise) {
-        return result
-          .then(() => {
-            return;
-          })
-          .then(() => instance as any);
-      }
-    }
-
-    if (isClass(instance)) {
-      const keys = (instance as any)[DI_INJECTABLE_PROPS];
-
-      if (keys) {
-        await Promise.all([...keys.keys()].map((key: string) => (instance as any)[key]));
-      }
-    }
-
-    detachLocalsContainer();
-
-    return instance as any;
-  }
-
-  /**
-   * Return the instance from injector registry
-   * @param target
-   */
-  static get<T = any>(target: TokenProvider): T {
-    return injector().get<T>(target)!;
-  }
-
-  static createDIContext() {
-    return new DIContext({
-      id: "id",
-      injector: injector(),
-      logger: logger()
-    });
-  }
-
-  protected static configure(settings: Partial<TsED.Configuration> = {}): Partial<TsED.Configuration> {
-    return {
-      ...settings,
-      env: getValue(settings, "env", Env.TEST),
-      logger: {
-        ...getValue(settings, "logger", {}),
-        level: getValue(settings, "logger.level", "off")
-      }
-    };
-  }
-}

package/src/node/utils/asyncHookContext.spec.ts

@@ -1,147 +0,0 @@
-import {DITest} from "../services/DITest.js";
-import {getContext, runInContext, setContext} from "./asyncHookContext.js";
-
-describe("asyncHookContext", () => {
-  beforeEach(() => DITest.create());
-  afterEach(() => DITest.reset());
-  it("should initiate the async hook context - promise", async () => {
-    const req = {type: "req"};
-    const res = {type: "res"};
-
-    function next(res: any, req: any) {
-      return Promise.resolve(getContext());
-    }
-
-    function nextContext(res: any, req: any, next: any) {
-      const $ctx: any = {
-        id: "id",
-        req,
-        res
-      };
-
-      setContext($ctx);
-
-      return next();
-    }
-
-    function app(req: any, res: any) {
-      return runInContext(undefined, () => nextContext(req, res, () => next(req, res)), DITest.injector);
-    }
-
-    const result = await app(req, res);
-
-    expect(result).toEqual({
-      id: "id",
-      req: {
-        type: "res"
-      },
-      res: {
-        type: "req"
-      }
-    });
-  });
-  it("should initiate the async hook context - promise - runInContext x2", async () => {
-    const req = {type: "req"};
-    const res = {type: "res"};
-
-    function next(res: any, req: any) {
-      return Promise.resolve(getContext());
-    }
-
-    function nextContext(res: any, req: any, next: any) {
-      const $ctx: any = {
-        id: "id",
-        req,
-        res
-      };
-
-      return runInContext($ctx, next);
-    }
-
-    function app(req: any, res: any) {
-      return runInContext(undefined, () => nextContext(req, res, () => next(req, res)), DITest.injector);
-    }
-
-    const result = await app(req, res);
-
-    expect(result).toEqual({
-      id: "id",
-      req: {
-        type: "res"
-      },
-      res: {
-        type: "req"
-      }
-    });
-  });
-  it("should initiate the async hook context - promise (initialValue)", async () => {
-    const req = {type: "req"};
-    const res = {type: "res"};
-
-    function next(res: any, req: any) {
-      return Promise.resolve(getContext({id: "id2"} as never));
-    }
-
-    function nextContext(res: any, req: any, next: any) {
-      const $ctx: any = {
-        id: "id",
-        req,
-        res
-      };
-
-      setContext($ctx);
-
-      return next();
-    }
-
-    function app(req: any, res: any) {
-      return runInContext(undefined, () => nextContext(req, res, () => next(req, res)), DITest.injector);
-    }
-
-    const result = await app(req, res);
-
-    expect(result).toEqual({
-      id: "id2"
-    });
-  });
-  it("should initiate the async hook context - promise + setTimeout", async () => {
-    const req = {type: "req"};
-    const res = {type: "res"};
-
-    function next(res: any, req: any) {
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(getContext());
-        }, 100);
-      });
-    }
-
-    function nextContext(res: any, req: any, next: any) {
-      const $ctx: any = {
-        id: "id",
-        req,
-        res
-      };
-
-      setContext($ctx);
-
-      return next();
-    }
-
-    function app(req: any, res: any) {
-      return runInContext(undefined, () => nextContext(req, res, () => next(req, res)), DITest.injector);
-    }
-
-    const result = await app(req, res);
-
-    expect(result).toEqual({
-      id: "id",
-      req: {
-        type: "res"
-      },
-      res: {
-        type: "req"
-      }
-    });
-  });
-});

package/src/node/utils/asyncHookContext.ts

@@ -1,48 +0,0 @@
-import {AsyncLocalStorage, AsyncResource} from "node:async_hooks";
-
-import {InjectorService} from "../../common/index.js";
-import type {DIContext} from "../domain/DIContext.js";
-
-const storage: AsyncLocalStorage<{current: DIContext | undefined}> = new AsyncLocalStorage();
-
-export function getAsyncStore() {
-  return storage;
-}
-
-export function useContextRef() {
-  return getAsyncStore().getStore();
-}
-
-export function getContext<Context = DIContext>(initialValue?: DIContext): Context | undefined {
-  return initialValue || (useContextRef()?.current as any);
-}
-
-export async function runInContext<Result = unknown>(
-  ctx: DIContext | undefined,
-  cb: (...args: unknown[]) => Result,
-  injector?: InjectorService
-): Promise<Result> {
-  const ref = useContextRef();
-
-  if (ref) {
-    ctx && setContext(ctx);
-    return cb();
-  } else {
-    injector = ctx?.injector || injector;
-    cb = (await injector?.alterAsync("$alterRunInContext", cb)) || cb;
-
-    return storage.run({current: ctx}, cb);
-  }
-}
-
-export function setContext(ctx: DIContext) {
-  const ref = useContextRef();
-
-  if (ref && !ref.current) {
-    ref.current = ctx;
-  }
-}
-
-export function bindContext(cb: any) {
-  return AsyncResource.bind(cb);
-}

package/src/node/utils/attachLogger.spec.ts

@@ -1,14 +0,0 @@
-import {Logger} from "@tsed/logger";
-
-import {injector} from "../../common/index.js";
-import {attachLogger} from "./attachLogger.js";
-
-describe("attachLogger", () => {
-  it("should attach logger", () => {
-    const $log = new Logger("test");
-
-    attachLogger($log);
-
-    expect(injector().logger).toEqual($log);
-  });
-});

package/src/node/utils/attachLogger.ts

@@ -1,7 +0,0 @@
-import {DILogger, injector} from "../../common/index.js";
-import {setLoggerConfiguration} from "./setLoggerConfiguration.js";
-
-export function attachLogger($log: DILogger) {
-  injector().logger = $log;
-  setLoggerConfiguration();
-}

package/src/node/utils/setLoggerConfiguration.spec.ts

@@ -1,43 +0,0 @@
-import {Logger} from "@tsed/logger";
-import {afterEach} from "vitest";
-
-import {destroyInjector, injector} from "../../common/index.js";
-import {setLoggerConfiguration} from "./setLoggerConfiguration.js";
-
-describe("setLoggerConfiguration", () => {
-  afterEach(() => destroyInjector());
-  it("should change the logger level depending on the configuration", () => {
-    injector().settings.set("logger.level", "info");
-
-    setLoggerConfiguration();
-
-    expect(injector().logger.level).toEqual("info");
-  });
-  it("should call $log.appenders.set()", () => {
-    injector().logger = new Logger();
-
-    vi.spyOn(injector().logger.appenders, "set").mockResolvedValue(undefined);
-
-    injector().settings.set("logger.format", "format");
-
-    setLoggerConfiguration();
-
-    expect(injector().logger.appenders.set).toHaveBeenCalledWith("stdout", {
-      type: "stdout",
-      levels: ["info", "debug"],
-      layout: {
-        type: "pattern",
-        pattern: "format"
-      }
-    });
-
-    expect(injector().logger.appenders.set).toHaveBeenCalledWith("stderr", {
-      levels: ["trace", "fatal", "error", "warn"],
-      type: "stderr",
-      layout: {
-        type: "pattern",
-        pattern: "format"
-      }
-    });
-  });
-});

package/src/node/utils/setLoggerConfiguration.ts

@@ -1,7 +0,0 @@
-import {setLoggerFormat} from "./setLoggerFormat.js";
-import {setLoggerLevel} from "./setLoggerLevel.js";
-
-export function setLoggerConfiguration() {
-  setLoggerLevel();
-  setLoggerFormat();
-}

package/src/node/utils/setLoggerFormat.ts

@@ -1,33 +0,0 @@
-import {logger} from "../../common/fn/logger.js";
-import {injector} from "../../common/index.js";
-
-/**
- * @ignore
- */
-export function setLoggerFormat() {
-  const {level, format} = injector().settings.logger;
-
-  if (level) {
-    injector().logger.level = level;
-  }
-
-  if (format && injector().logger.appenders) {
-    logger().appenders.set("stdout", {
-      type: "stdout",
-      levels: ["info", "debug"],
-      layout: {
-        type: "pattern",
-        pattern: format
-      }
-    });
-
-    logger().appenders.set("stderr", {
-      levels: ["trace", "fatal", "error", "warn"],
-      type: "stderr",
-      layout: {
-        type: "pattern",
-        pattern: format
-      }
-    });
-  }
-}

package/src/node/utils/setLoggerLevel.ts

@@ -1,12 +0,0 @@
-import {injector} from "../../common/index.js";
-
-/**
- * @ignore
- */
-export function setLoggerLevel() {
-  const {level} = injector().settings.logger;
-
-  if (level) {
-    injector().logger.level = level;
-  }
-}

package/vite.config.mts

@@ -1,45 +0,0 @@
-import {defineConfig} from "vite";
-import {join} from "node:path";
-import {extname, relative} from "path";
-import {fileURLToPath} from "node:url";
-import {globbySync} from "globby";
-
-// https://vitejs.dev/config/
-export default defineConfig({
-  plugins: [],
-  build: {
-    assetsInlineLimit: 0,
-    sourcemap: true,
-    outDir: "lib/browser",
-    lib: {
-      entry: join(import.meta.dirname, "src/common/index.ts"),
-      formats: ["es"]
-    },
-    rollupOptions: {
-      external: [/node_modules\/(.*)/, /^@tsed\//],
-      input: Object.fromEntries(
-        globbySync("src/common/**/*.ts", {
-          ignore: [
-            "**/*.spec.{ts,tsx}",
-            "**/*.stories.{ts,tsx}",
-            "**/__mocks__/**",
-            "**/__mock__/**",
-            "**/interfaces/**"
-          ]
-        }).map((file) => [
-          // The name of the entry point
-          // lib/nested/foo.ts becomes nested/foo
-          relative("src", file.slice(0, file.length - extname(file).length)),
-          // The absolute path to the entry file
-          // lib/nested/foo.ts becomes /project/lib/nested/foo.ts
-          fileURLToPath(new URL(file, import.meta.url))
-        ])
-      ),
-      output: {
-        assetFileNames: "assets/[name][extname]",
-        chunkFileNames: "chunks/[name].js",
-        entryFileNames: "[name].js"
-      }
-    }
-  }
-});

package/vitest.config.mts

@@ -1,21 +0,0 @@
-// @ts-ignore
-import {presets} from "@tsed/vitest/presets";
-import {defineConfig} from "vitest/config";
-
-export default defineConfig(
-  {
-    ...presets,
-    test: {
-      ...presets.test,
-      coverage: {
-        ...presets.test.coverage,
-        thresholds: {
-          statements: 0,
-          branches: 0,
-          functions: 0,
-          lines: 0
-        }
-      }
-    }
-  }
-);