@tsed/di 8.0.0 → 8.0.2

package/src/node/services/DITest.ts

@@ -0,0 +1,119 @@
+import {Env, getValue, isClass, isObject} from "@tsed/core";
+import {$log} from "@tsed/logger";
+
+import {cleanAllLocalsContainer, detachLocalsContainer, localsContainer} from "../../common/fn/localsContainer.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 {logger} from "../fn/logger.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 & OnInit = inject<T & OnInit>(target, {locals, rebuild: true});
+
+    if (instance && isObject(instance) && "$onInit" in instance) {
+      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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,48 @@
+import {AsyncLocalStorage, AsyncResource} from "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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,7 @@
+import {DILogger, injector, InjectorService} 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

@@ -0,0 +1,43 @@
+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

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

package/src/node/utils/setLoggerFormat.ts

@@ -0,0 +1,33 @@
+import {injector} from "../../common/index.js";
+import {logger} from "../fn/logger.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

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