@tsed/di 8.0.1 → 8.0.2

package/src/common/utils/getConfiguration.spec.ts

@@ -0,0 +1,40 @@
+import {Configuration} from "../decorators/configuration.js";
+import {getConfiguration} from "./getConfiguration.js";
+
+class MyController1 {}
+
+class MyController2 {}
+
+describe("getConfiguration", () => {
+  it("should return configuration", () => {
+    @Configuration({test: "test"})
+    class MyModule {}
+
+    expect(getConfiguration(MyModule)).toEqual({
+      test: "test",
+      mount: {}
+    });
+  });
+
+  it("should return configuration (2)", () => {
+    @Configuration({
+      mount: {
+        "/v1": [MyController1]
+      }
+    })
+    class MyModule {}
+
+    expect(
+      getConfiguration(MyModule, {
+        mount: {
+          "/v2": [MyController2]
+        }
+      })
+    ).toEqual({
+      mount: {
+        "/v1": [MyController1],
+        "/v2": [MyController2]
+      }
+    });
+  });
+});

package/src/common/utils/getConfiguration.ts

@@ -0,0 +1,20 @@
+import {Store, Type} from "@tsed/core";
+
+export function mergeMount(m1: any = {}, m2: any = {}) {
+  return Object.entries(m2).reduce((mount, [key, controllers]) => {
+    return {
+      ...mount,
+      [key]: (mount[key] || []).concat(controllers)
+    };
+  }, m1);
+}
+
+export function getConfiguration(module: Type<any>, configuration: any = {}) {
+  const store = Store.from(module).get("configuration") || {};
+
+  return {
+    ...store,
+    ...configuration,
+    mount: mergeMount(store.mount, configuration.mount)
+  };
+}

package/src/common/utils/getConstructorDependencies.ts

@@ -0,0 +1,9 @@
+import {Metadata} from "@tsed/core";
+
+export function getConstructorDependencies(target: any, propertyKey?: string | symbol | undefined) {
+  return Metadata.getOwn("override:ctor:design:paramtypes", target, propertyKey) || [...Metadata.getParamTypes(target, propertyKey)] || [];
+}
+
+export function setConstructorDependencies(target: any, deps: any[]) {
+  Metadata.set("override:ctor:design:paramtypes", deps, target);
+}

package/src/common/utils/providerBuilder.ts

@@ -0,0 +1,81 @@
+import "../registries/ProviderRegistry.js";
+
+import {Store, type Type} from "@tsed/core";
+
+import {ProviderType} from "../domain/ProviderType.js";
+import {injector} from "../fn/injector.js";
+import type {ProviderOpts} from "../interfaces/ProviderOpts.js";
+import type {TokenProvider} from "../interfaces/TokenProvider.js";
+import {GlobalProviders} from "../registries/GlobalProviders.js";
+
+type ProviderBuilder<Token extends TokenProvider, BaseProvider, T extends object> = {
+  [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: (value: T[K]) => ProviderBuilder<Token, BaseProvider, T>;
+} & {
+  inspect(): BaseProvider;
+  store(): Store;
+  token(): Token;
+  factory(f: (...args: unknown[]) => unknown): ProviderBuilder<Token, BaseProvider, T>;
+  asyncFactory(f: (...args: unknown[]) => Promise<unknown>): ProviderBuilder<Token, BaseProvider, T>;
+  value(v: unknown): ProviderBuilder<Token, BaseProvider, T>;
+  class(c: Type): ProviderBuilder<Token, BaseProvider, T>;
+};
+
+export function providerBuilder<Provider, Picked extends keyof Provider>(props: string[], baseOpts: Partial<ProviderOpts<Provider>> = {}) {
+  return <Token extends TokenProvider>(
+    token: Token,
+    options: Partial<ProviderOpts<Type>> = {}
+  ): ProviderBuilder<Token, Provider, Pick<Provider, Picked>> => {
+    const merged = {
+      global: !injector().isLoaded(),
+      ...options,
+      ...baseOpts,
+      token
+    };
+
+    const provider = GlobalProviders.merge(token, merged);
+
+    if (!merged.global) {
+      injector().setProvider(token, provider);
+    }
+
+    return props.reduce(
+      (acc, prop) => {
+        return {
+          ...acc,
+          [prop]: function (value: any) {
+            (provider as any)[prop] = value;
+            return this;
+          }
+        };
+      },
+      {
+        factory(factory: any) {
+          provider.useFactory = factory;
+          return this;
+        },
+        asyncFactory(asyncFactory: any) {
+          provider.useAsyncFactory = asyncFactory;
+          return this;
+        },
+        value(value: any) {
+          provider.useValue = value;
+          provider.type = ProviderType.VALUE;
+          return this;
+        },
+        class(k: any) {
+          provider.useClass = k;
+          return this;
+        },
+        store() {
+          return provider.store;
+        },
+        inspect() {
+          return provider;
+        },
+        token() {
+          return provider.token as Token;
+        }
+      } as ProviderBuilder<Token, Provider, Pick<Provider, Picked>>
+    );
+  };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./common/index.js";
+export * from "./node/index.js";

package/src/node/decorators/injectContext.spec.ts

@@ -0,0 +1,60 @@
+import {afterEach, beforeEach, expect} from "vitest";
+
+import {Injectable} from "../../common/index.js";
+import {DIContext} from "../domain/DIContext.js";
+import {DITest} from "../services/DITest.js";
+import {runInContext} from "../utils/asyncHookContext.js";
+import {InjectContext} from "./injectContext.js";
+
+describe("InjectContext", () => {
+  beforeEach(() => DITest.create());
+  afterEach(() => DITest.reset());
+
+  it("should inject a context", async () => {
+    @Injectable()
+    class MyService {
+      @InjectContext()
+      ctx: DIContext;
+    }
+
+    const $ctx = new DIContext({
+      id: "test",
+      logger: DITest.injector.logger,
+      injector: DITest.injector,
+      maxStackSize: 0
+    });
+
+    const myService = await DITest.invoke(MyService);
+
+    await runInContext($ctx, () => {
+      expect(myService.ctx).toBeInstanceOf(DIContext);
+      expect(myService.ctx).toEqual($ctx);
+    });
+
+    expect(myService.ctx).toBeInstanceOf(DIContext);
+    expect(myService.ctx).not.toEqual($ctx);
+  });
+  it("should inject a context and get value", async () => {
+    @Injectable()
+    class MyService {
+      @InjectContext((o) => o.get("test"))
+      test: string;
+    }
+
+    const $ctx = new DIContext({
+      id: "test",
+      logger: DITest.injector.logger,
+      injector: DITest.injector,
+      maxStackSize: 0
+    });
+    $ctx.set("test", "value");
+
+    const myService = await DITest.invoke(MyService);
+
+    await runInContext($ctx, () => {
+      expect(myService.test).toEqual("value");
+    });
+
+    expect(myService.test).toEqual(undefined);
+  });
+});

package/src/node/decorators/injectContext.ts

@@ -0,0 +1,29 @@
+import {catchError} from "@tsed/core";
+
+import {DIContext} from "../domain/DIContext.js";
+import {context} from "../fn/context.js";
+
+/**
+ * Inject a context like PlatformContext or any BaseContext.
+ *
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   @InjectContext()
+ *   ctx?: Context;
+ * }
+ * ```
+ *
+ * @returns {Function}
+ * @decorator
+ */
+export function InjectContext(transform: ($ctx: DIContext) => unknown = (o) => o): PropertyDecorator {
+  return (target: any, propertyKey: string): any | void => {
+    catchError(() => Reflect.deleteProperty(target, propertyKey));
+    Reflect.defineProperty(target, propertyKey, {
+      get() {
+        return transform(context());
+      }
+    });
+  };
+}

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

@@ -0,0 +1,277 @@
+import {ContextLogger} from "./ContextLogger.js";
+
+function getIgnoreLogFixture(ignore: string[], url: string) {
+  const ignoreReg = ignore.map((pattern: string | RegExp) => (typeof pattern === "string" ? new RegExp(pattern, "gi") : pattern));
+  return (ignore: boolean, data: any) => {
+    return !!ignoreReg.find((reg) => !!url.match(reg));
+  };
+}
+
+describe("ContextLogger", () => {
+  it("should create a new Context and log all", () => {
+    const logger = {
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      fatal: vi.fn(),
+      trace: vi.fn()
+    };
+
+    const contextLogger = new ContextLogger({
+      event: {
+        request: {},
+        response: {}
+      },
+      logger,
+      id: "id",
+      dateStart: new Date("2019-01-01")
+    });
+
+    contextLogger.alterIgnoreLog(getIgnoreLogFixture(["/admin"], "/"));
+    contextLogger.alterLog((o: any, level: "debug" | "info" | "warn" | "error" | "off" | "all", withRequest: boolean) => {
+      switch (level) {
+        case "info":
+          return {...o, minimal: "minimal"};
+        default:
+          return {...o, complete: "complete"};
+      }
+    });
+
+    vi.spyOn(contextLogger as any, "getDuration").mockReturnValue(1);
+
+    // WHEN
+    contextLogger.debug({test: "test"});
+    contextLogger.info({test: "test"});
+    contextLogger.info("message");
+    contextLogger.warn({test: "test"});
+    contextLogger.error({test: "test"});
+    contextLogger.fatal({test: "test"});
+    contextLogger.trace({test: "test"});
+
+    contextLogger.flush();
+
+    // THEN
+    expect(logger.info).toHaveBeenCalledWith({
+      minimal: "minimal",
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+    expect(logger.info).toHaveBeenCalledWith({
+      minimal: "minimal",
+      duration: 1,
+      reqId: "id",
+      message: "message",
+      time: expect.any(Date)
+    });
+    expect(logger.debug).toHaveBeenCalledWith({
+      complete: "complete",
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+    expect(logger.warn).toHaveBeenCalledWith({
+      complete: "complete",
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+    expect(logger.error).toHaveBeenCalledWith({
+      complete: "complete",
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+    expect(logger.fatal).toHaveBeenCalledWith({
+      complete: "complete",
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+    expect(logger.trace).toHaveBeenCalledWith({
+      complete: "complete",
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+  });
+  it("should create a new Context and log all (with minimalRequestPicker)", () => {
+    const logger = {
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      trace: vi.fn()
+    };
+
+    const contextLogger = new ContextLogger({
+      event: {
+        request: {},
+        response: {}
+      },
+      logger,
+      id: "id",
+      startDate: new Date("2019-01-01")
+    });
+
+    contextLogger.alterIgnoreLog(getIgnoreLogFixture(["/admin"], "/url"));
+
+    vi.spyOn(contextLogger as any, "getDuration").mockReturnValue(1);
+
+    // WHEN
+    contextLogger.debug({test: "test"});
+    contextLogger.info({test: "test"});
+    contextLogger.info("message");
+    contextLogger.warn({test: "test"});
+    contextLogger.error({test: "test"});
+    contextLogger.trace({test: "test"});
+
+    contextLogger.flush();
+
+    // THEN
+    expect(logger.info).toHaveBeenCalledWith({
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+    expect(logger.info).toHaveBeenCalledWith({
+      duration: 1,
+      reqId: "id",
+      message: "message",
+      time: expect.any(Date)
+    });
+    expect(logger.debug).toHaveBeenCalledWith({
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+    expect(logger.warn).toHaveBeenCalledWith({
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+    expect(logger.error).toHaveBeenCalledWith({
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+    expect(logger.trace).toHaveBeenCalledWith({
+      duration: 1,
+      reqId: "id",
+      test: "test",
+      time: expect.any(Date)
+    });
+  });
+  it("should create a new Context and log nothing when pattern match with url", () => {
+    const logger = {
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      trace: vi.fn()
+    };
+
+    const contextLogger = new ContextLogger({
+      logger,
+      event: {
+        request: {},
+        response: {}
+      },
+      id: "id",
+      startDate: new Date("2019-01-01"),
+      additionalProps: {
+        url: "/"
+      }
+    });
+
+    contextLogger.alterIgnoreLog(getIgnoreLogFixture(["/admin"], "/admin"));
+
+    vi.spyOn(contextLogger as any, "getDuration").mockReturnValue(1);
+
+    // WHEN
+    contextLogger.info({test: "test"});
+    contextLogger.flush();
+
+    // THEN
+    return expect(logger.info).not.toHaveBeenCalled();
+  });
+  it("should create a new Context and flush log when maxStackSize is reached", () => {
+    const logger = {
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      trace: vi.fn()
+    };
+
+    const contextLogger = new ContextLogger({
+      logger,
+      event: {
+        request: {},
+        response: {}
+      },
+      id: "id",
+      startDate: new Date("2019-01-01"),
+      maxStackSize: 2
+    });
+
+    contextLogger.maxStackSize = 2;
+
+    vi.spyOn(contextLogger as any, "getDuration").mockReturnValue(1);
+
+    // WHEN
+    contextLogger.info({test: "test"});
+    contextLogger.info({test: "test"});
+    contextLogger.info({test: "test"});
+    contextLogger.info({test: "test"});
+
+    // THEN
+    return expect(logger.info).toHaveBeenCalledTimes(3);
+  });
+  it("should do nothing when the log level is off", () => {
+    const logger = {
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      trace: vi.fn()
+    };
+
+    const contextLogger = new ContextLogger({
+      event: {
+        request: {},
+        response: {}
+      },
+      logger,
+      id: "id",
+      dateStart: new Date("2019-01-01"),
+      level: "off"
+    });
+
+    vi.spyOn(contextLogger as any, "getDuration").mockReturnValue(1);
+
+    // WHEN
+    contextLogger.debug({test: "test"});
+    contextLogger.info({test: "test"});
+    contextLogger.info("message");
+    contextLogger.warn({test: "test"});
+    contextLogger.error({test: "test"});
+    contextLogger.trace({test: "test"});
+
+    contextLogger.flush();
+
+    // THEN
+    expect(logger.info).not.toHaveBeenCalled();
+  });
+});

package/src/node/domain/ContextLogger.ts

@@ -0,0 +1,137 @@
+import {Hooks} from "@tsed/hooks";
+import {levels, LogLevel} from "@tsed/logger";
+
+import {DILogger} from "../../common/index.js";
+import {logger as injectLogger} from "../fn/logger.js";
+
+export interface ContextLoggerOptions extends Record<string, any> {
+  id: string;
+  logger?: DILogger;
+  level?: "debug" | "info" | "warn" | "error" | "off" | "all";
+  maxStackSize?: number;
+  additionalProps?: Record<any, any>;
+}
+
+const LEVELS: Record<string, LogLevel> = levels();
+
+export class ContextLogger {
+  readonly dateStart: Date;
+  readonly id: string;
+  readonly #additionalProps?: Record<string, unknown>;
+
+  maxStackSize: number;
+  level: LogLevel;
+
+  #hooks?: Hooks;
+  #stack?: any[];
+  #logger: any;
+
+  constructor({id, logger, dateStart = new Date(), level = "all", maxStackSize = 30, additionalProps}: ContextLoggerOptions) {
+    this.dateStart = dateStart;
+    this.id = id;
+    this.#logger = logger || injectLogger();
+    this.#additionalProps = additionalProps;
+    this.level = (LEVELS[level.toUpperCase()] || LEVELS.ALL) as LogLevel;
+    this.maxStackSize = maxStackSize;
+  }
+
+  get hooks() {
+    return (this.#hooks = this.#hooks || new Hooks());
+  }
+
+  private get stack() {
+    return (this.#stack = this.#stack || []);
+  }
+
+  alterLog(cb: (data: any, level: "debug" | "info" | "warn" | "error" | "all", withRequest: boolean) => any) {
+    return this.hooks.on("log", cb);
+  }
+
+  alterIgnoreLog(cb: (ignore: boolean, data: any) => boolean) {
+    return this.hooks.on("ignore", cb);
+  }
+
+  info(obj: any) {
+    this.run(levels().INFO, obj);
+    return this;
+  }
+
+  debug(obj: any) {
+    this.run(levels().DEBUG, obj);
+    return this;
+  }
+
+  warn(obj: any) {
+    this.run(levels().WARN, obj);
+    return this;
+  }
+
+  error(obj: any) {
+    this.run(levels().ERROR, obj);
+    return this;
+  }
+
+  fatal(obj: any) {
+    this.run(levels().FATAL, obj);
+    return this;
+  }
+
+  trace(obj: any) {
+    this.run(levels().TRACE, obj);
+    return this;
+  }
+
+  public flush(stream = false) {
+    if (this.stack.length) {
+      this.stack.forEach(({level, data}: any) => {
+        this.#logger[level](data);
+      });
+
+      this.#stack = [];
+    }
+
+    if (stream) {
+      this.maxStackSize = 0;
+    }
+  }
+
+  public isLevelEnabled(otherLevel: string | LogLevel) {
+    return this.level.isLessThanOrEqualTo(otherLevel);
+  }
+
+  /**
+   * Return the duration between the time when LogIncomingRequest has handle the request and now.
+   * @returns {number}
+   */
+  protected getDuration(): number {
+    return new Date().getTime() - this.dateStart.getTime();
+  }
+
+  protected getData(obj: any) {
+    if (typeof obj === "string") {
+      obj = {message: obj};
+    }
+
+    return {...this.#additionalProps, reqId: this.id, time: new Date(), duration: this.getDuration(), ...obj};
+  }
+
+  protected run(level: LogLevel, obj: any, withRequest?: boolean) {
+    if (!this.isLevelEnabled(level)) {
+      return;
+    }
+
+    const ignore = this.#hooks?.alter("ignore", false, [obj]);
+
+    if (!ignore) {
+      const levelStr = level.levelStr.toLowerCase();
+
+      obj = this.hooks.alter("log", this.getData(obj), [levelStr, withRequest]);
+
+      this.stack.push({level: levelStr, data: obj});
+    }
+
+    if (this.maxStackSize < this.stack.length || [levels().FATAL, levels().ERROR].includes(level)) {
+      this.flush();
+    }
+  }
+}