@tsed/di 8.0.0 → 8.0.2

package/src/node/domain/DIContext.spec.ts

@@ -0,0 +1,103 @@
+import {logger} from "../fn/logger.js";
+import {DITest} from "../services/DITest.js";
+import {DIContext} from "./DIContext.js";
+
+describe("DIContext", () => {
+  beforeEach(() => DITest.create());
+  beforeEach(() => {
+    vi.spyOn(logger(), "info").mockReturnValue(undefined);
+  });
+  afterEach(() => DITest.reset());
+  describe("constructor", () => {
+    it("should create a new Context and skip log", () => {
+      const context = new DIContext({
+        event: {
+          response: {},
+          request: {
+            url: "/admin"
+          }
+        },
+        id: "id",
+        maxStackSize: 0
+      });
+
+      expect(context.id).toEqual("id");
+      expect(context.dateStart).toBeInstanceOf(Date);
+      expect(context.container).toBeInstanceOf(Map);
+      expect(context.env).toEqual("test");
+      expect(context.PLATFORM).toEqual("DI");
+
+      context.logger.info("test");
+
+      expect(logger().info).toHaveBeenCalled();
+
+      context.destroy();
+    });
+    it("should create a new Context and log event", () => {
+      const context = new DIContext({
+        id: "id",
+        event: {
+          response: {},
+          request: {url: "/"}
+        },
+        maxStackSize: 0,
+        platform: "OTHER"
+      });
+
+      context.next = vi.fn();
+
+      expect(context.id).toEqual("id");
+      expect(context.dateStart).toBeInstanceOf(Date);
+      expect(context.container).toBeInstanceOf(Map);
+      expect(context.env).toEqual("test");
+      expect(context.PLATFORM).toEqual("OTHER");
+
+      context.next();
+      context.logger.info("test");
+
+      expect(logger().info).toHaveBeenCalled();
+    });
+  });
+
+  describe("cache()", () => {
+    it("should cache data", () => {
+      const context = new DIContext({
+        event: {
+          response: {},
+          request: {url: "/admin"}
+        },
+        id: "id",
+        maxStackSize: 0,
+        ignoreUrlPatterns: ["/admin", /\/admin2/]
+      });
+      const resolver = vi.fn().mockReturnValue("test");
+
+      const result = context.cache("key", resolver);
+      const result2 = context.cache("key", resolver);
+
+      expect(result).toEqual(result2);
+      expect(resolver).toHaveBeenCalledTimes(1);
+      expect(context.delete("key")).toEqual(true);
+    });
+  });
+  describe("cacheAsync()", () => {
+    it("should cache data", async () => {
+      const context = new DIContext({
+        event: {
+          response: {},
+          request: {url: "/admin"}
+        },
+        id: "id",
+        maxStackSize: 0,
+        ignoreUrlPatterns: ["/admin", /\/admin2/]
+      });
+      const resolver = vi.fn().mockResolvedValue("test");
+
+      const result = await context.cacheAsync("key", resolver);
+      const result2 = await context.cacheAsync("key", resolver);
+
+      expect(result).toEqual(result2);
+      expect(resolver).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/node/domain/DIContext.ts

@@ -0,0 +1,115 @@
+import {injector, InjectorService, LocalsContainer} from "../../common/index.js";
+import {ContextLogger, ContextLoggerOptions} from "./ContextLogger.js";
+
+export interface DIContextOptions extends Omit<ContextLoggerOptions, "dateStart"> {
+  id: string;
+  platform?: string;
+}
+
+export class DIContext {
+  [x: string]: any;
+
+  readonly PLATFORM: string = "DI";
+  #container?: LocalsContainer;
+  #cache?: Map<any, any>;
+  #logger?: ContextLogger;
+
+  constructor(public opts: DIContextOptions) {
+    this.PLATFORM = opts.platform || this.PLATFORM;
+  }
+
+  /**
+   * Logger attached to the context request.
+   */
+  get logger() {
+    this.#logger = this.#logger || new ContextLogger(this.opts);
+    return this.#logger;
+  }
+
+  /**
+   * Request id generated by @@contextMiddleware@@.
+   *
+   * ::: tip
+   * By default Ts.ED generate uuid like that `uuidv4().replace(/-/gi, ""))`.
+   * Dash are removed to simplify tracking logs in Kibana
+   * :::
+   *
+   * ::: tip
+   * Request id can by customized by changing the server configuration.
+   *
+   * ```typescript
+   * @Configuration({
+   *   logger: {
+   *     reqIdBuilder: createUniqId // give your own id generator function
+   *   }
+   * })
+   * class Server {
+   *
+   * }
+   * ```
+   * :::
+   *
+   */
+  get id() {
+    return this.opts.id;
+  }
+
+  get dateStart() {
+    return this.logger.dateStart;
+  }
+
+  get injector(): InjectorService {
+    return injector();
+  }
+
+  get env() {
+    return this.injector.settings.get("env");
+  }
+
+  /**
+   * The request container used by the Ts.ED DI. It contains all services annotated with `@Scope(ProviderScope.REQUEST)`
+   */
+  get container() {
+    return (this.#container = this.#container || new LocalsContainer());
+  }
+
+  destroy(): Promise<any> {
+    return Promise.all([this.#container?.destroy(), this.#logger?.flush(true)]);
+  }
+
+  cache<Value = any>(key: string, cb: () => Value): Value {
+    if (!this.has(key)) {
+      this.set(key, cb());
+    }
+
+    return this.get(key);
+  }
+
+  async cacheAsync<Value = any>(key: string, cb: () => Promise<Value>): Promise<Value> {
+    if (!this.has(key)) {
+      this.set(key, await cb());
+    }
+
+    return this.get(key);
+  }
+
+  delete(key: any): boolean {
+    return !!this.#cache?.delete(key);
+  }
+
+  get<T = any>(key: any): T {
+    return this.#cache?.get(key);
+  }
+
+  has(key: any): boolean {
+    return !!this.#cache?.has(key);
+  }
+
+  set(key: any, value: any): this {
+    this.#cache = this.#cache || new Map<any, any>();
+    this.#cache.set(key, value);
+    return this;
+  }
+}
+
+export type BaseContext = DIContext & TsED.Context;

package/src/node/fn/context.ts

@@ -0,0 +1,24 @@
+import {v4} from "uuid";
+
+import {injector} from "../../common/index.js";
+import {DIContext} from "../domain/DIContext.js";
+import {getContext} from "../utils/asyncHookContext.js";
+
+/**
+ * Get the current DIContext instance using async hook node.js api.
+ *
+ * ::: warning
+ * This function isn't available in the browser context.
+ * :::
+ */
+export function context<Ctx = DIContext>(): Ctx {
+  return (
+    getContext<Ctx>() ||
+    (new DIContext({
+      id: v4(),
+      logger: injector().logger,
+      injector: injector(),
+      maxStackSize: 0
+    }) as Ctx)
+  );
+}

package/src/node/fn/logger.spec.ts

@@ -0,0 +1,46 @@
+import {Logger} from "@tsed/logger";
+import {beforeEach} from "vitest";
+
+import {inject, Injectable} from "../../common/index.js";
+import {ContextLogger} from "../domain/ContextLogger.js";
+import {context} from "../fn/context.js";
+import {DITest} from "../services/DITest.js";
+import {runInContext} from "../utils/asyncHookContext.js";
+import {contextLogger, logger} from "./logger.js";
+
+describe("DILogger", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  it("should inject logger in another service (decorator less)", async () => {
+    @Injectable()
+    class MyService {
+      logger = logger();
+    }
+
+    const service = inject(MyService, {rebuild: true});
+
+    expect(service.logger).toBeInstanceOf(Logger);
+  });
+
+  it("should inject context logger in another service", async () => {
+    @Injectable()
+    class MyService {
+      get logger() {
+        return contextLogger();
+      }
+    }
+
+    const service = inject(MyService, {rebuild: true});
+
+    expect(service.logger).toBeInstanceOf(ContextLogger);
+
+    const $ctx = context();
+
+    await runInContext($ctx, () => {
+      expect(service.logger).toEqual(context().logger);
+    });
+
+    expect(service.logger).not.toEqual(context().logger);
+  });
+});

package/src/node/fn/logger.ts

@@ -0,0 +1,17 @@
+import {injector} from "../../common/index.js";
+import {context} from "./context.js";
+
+/**
+ * Get the current `injector.logger` instance.
+ */
+export function logger() {
+  return injector().logger;
+}
+
+/**
+ * Get the current logger instance. If the logger() function is invoked in Request context, it will return the logger instance attached to the request context.
+ * Otherwise, it will return the logger instance attached to the DI context.
+ */
+export function contextLogger() {
+  return context().logger;
+}

package/src/node/index.ts

@@ -0,0 +1,16 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./decorators/injectContext.js";
+export * from "./domain/ContextLogger.js";
+export * from "./domain/DIContext.js";
+export * from "./fn/context.js";
+export * from "./fn/logger.js";
+export * from "./interfaces/AlterRunInContext.js";
+export * from "./services/DILogger.js";
+export * from "./services/DITest.js";
+export * from "./utils/asyncHookContext.js";
+export * from "./utils/attachLogger.js";
+export * from "./utils/setLoggerConfiguration.js";
+export * from "./utils/setLoggerFormat.js";
+export * from "./utils/setLoggerLevel.js";

package/src/node/integration/async-factory-invoke.spec.ts

@@ -0,0 +1,58 @@
+import {DITest, Inject, Injectable, registerProvider} from "../../index.js";
+
+const PrimaryPostgresDb = Symbol.for("PrimaryPostgresDb");
+type PrimaryPostgresDb = {id: string};
+
+registerProvider({
+  token: PrimaryPostgresDb,
+  useAsyncFactory: () => {
+    return Promise.resolve({
+      id: "id"
+    });
+  }
+});
+
+@Injectable()
+export class MyService {
+  @Inject(PrimaryPostgresDb)
+  protected dataSource: PrimaryPostgresDb;
+
+  me() {
+    return this.dataSource.id;
+  }
+}
+
+describe("AsyncFactory", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  it("should inject async factory and return resolve promise value (first test)", () => {
+    const service = DITest.get<MyService>(MyService);
+
+    const result = service.me();
+
+    expect(result).toEqual("id");
+  });
+
+  it("should inject async factory and return resolve promise value (second test)", () => {
+    const service = DITest.get<MyService>(MyService);
+
+    const result = service.me();
+    expect(result).toEqual("id");
+  });
+
+  it("should inject async factory and return resolve promise value (first test - invoke)", async () => {
+    const service = await DITest.invoke<MyService>(MyService, []);
+
+    const result = service.me();
+
+    expect(result).toEqual("id");
+  });
+
+  it("should inject async factory and return resolve promise value (second test - invoke)", async () => {
+    const service = await DITest.invoke<MyService>(MyService, []);
+
+    const result = service.me();
+    expect(result).toEqual("id");
+  });
+});

package/src/node/integration/inject-context.spec.ts

@@ -0,0 +1,29 @@
+import {Injectable} from "../../common/index.js";
+import {InjectContext} from "../decorators/injectContext.js";
+import {DIContext} from "../domain/DIContext.js";
+import {DITest} from "../services/DITest.js";
+import {runInContext} from "../utils/asyncHookContext.js";
+
+@Injectable()
+class MyService {
+  @InjectContext()
+  $ctx: DIContext;
+
+  get() {
+    return this.$ctx.id;
+  }
+}
+
+describe("InjectContext", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  it("should inject context", async () => {
+    const ctx = DITest.createDIContext();
+    const service = DITest.get<MyService>(MyService);
+
+    const result = await runInContext(ctx, () => service.get());
+
+    expect(result).toEqual("id");
+  });
+});

package/src/node/integration/invoke-oninit.spec.ts

@@ -0,0 +1,25 @@
+import {DITest, Inject, Injectable, registerProvider} from "../../index.js";
+
+@Injectable()
+export class MyService {
+  id = "id";
+  $onInit() {
+    return new Promise((resolve) =>
+      setTimeout(() => {
+        this.id = "id2";
+        resolve({});
+      }, 1)
+    );
+  }
+}
+
+describe("OnInit Invoke", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  it("should inject async factory and return resolve promise value", async () => {
+    const service = await DITest.invoke<MyService>(MyService, []);
+
+    expect(service.id).toEqual("id2");
+  });
+});

package/src/node/interfaces/AlterRunInContext.ts

@@ -0,0 +1,3 @@
+export interface AlterRunInContext {
+  $alterRunInContext(next: (...args: unknown[]) => unknown): () => unknown | Promise<() => unknown>;
+}

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

@@ -0,0 +1,24 @@
+import "./DILogger.js";
+
+import {Logger} from "@tsed/logger";
+import {beforeEach} from "vitest";
+
+import {Inject, inject, Injectable, injector} from "../../common/index.js";
+import {DITest} from "./DITest.js";
+
+describe("DILogger", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  it("should inject logger in another service", async () => {
+    @Injectable()
+    class MyService {
+      @Inject()
+      logger: Logger;
+    }
+
+    const service = inject(MyService, {rebuild: true});
+
+    expect(service.logger).toEqual(injector().logger);
+  });
+});

package/src/node/services/DILogger.ts

@@ -0,0 +1,6 @@
+import {Logger} from "@tsed/logger";
+
+import {injectable} from "../../common/fn/injectable.js";
+import {logger} from "../fn/logger.js";
+
+injectable(Logger).factory(logger);

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

@@ -0,0 +1,109 @@
+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
+      });
+    });
+  });
+});