@tsed/di 8.11.1 → 8.11.2-rc.1

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

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

@@ -1,21 +0,0 @@
-import {Store} from "@tsed/core/types/Store.js";
-import {Type} from "@tsed/core/types/Type.js";
-
-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

@@ -1,9 +0,0 @@
-import {Metadata} from "@tsed/core/types/Metadata.js";
-
-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

@@ -1,95 +0,0 @@
-import "../registries/ProviderRegistry.js";
-
-import {Store} from "@tsed/core/types/Store.js";
-import {type Type} from "@tsed/core/types/Type.js";
-
-import {ProviderType} from "../domain/ProviderType.js";
-import {injector} from "../fn/injector.js";
-import type {ProviderOpts} from "../interfaces/ProviderOpts.js";
-import type {FactoryTokenProvider, TokenProvider} from "../interfaces/TokenProvider.js";
-import {GlobalProviders} from "../registries/GlobalProviders.js";
-
-type BaseMethodsProvider<TypeOf, BaseProvider, T extends object> = {
-  [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: (value: T[K]) => ProviderBuilder<TypeOf, BaseProvider, T>;
-};
-
-type ProviderBuilder<TypeOf, BaseProvider, T extends object> = BaseMethodsProvider<TypeOf, BaseProvider, T> & {
-  inspect(): BaseProvider;
-  store(): Store;
-  token(): TypeOf;
-  factory<FactoryReturn>(f: (...args: unknown[]) => FactoryReturn): ProviderBuilder<FactoryTokenProvider<FactoryReturn>, BaseProvider, T>;
-  asyncFactory<FactoryReturn>(
-    f: (...args: unknown[]) => Promise<FactoryReturn>
-  ): ProviderBuilder<FactoryTokenProvider<FactoryReturn>, BaseProvider, T>;
-  value<Value>(v: Value): ProviderBuilder<FactoryTokenProvider<Value>, BaseProvider, T>;
-  class<TokenKlass>(c: Type<TokenKlass>): ProviderBuilder<TokenKlass, BaseProvider, T>;
-};
-
-export type ProviderBuilderFn<Provider, Picked extends keyof Provider> = <TypeOf extends TokenProvider>(
-  token: TypeOf,
-  options?: Partial<ProviderOpts<Type>>
-) => ProviderBuilder<TypeOf, Provider, Pick<Provider, Picked>>;
-
-export function providerBuilder<Provider, Picked extends keyof Provider>(
-  props: string[],
-  baseOpts: Partial<ProviderOpts<Provider>> = {}
-): ProviderBuilderFn<Provider, Picked> {
-  return <TypeOf extends TokenProvider>(token: TypeOf, options: Partial<ProviderOpts<Type>> = {}) => {
-    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: Function) {
-          provider.reset();
-          provider.useFactory = factory;
-          return this;
-        },
-        asyncFactory(asyncFactory: Function) {
-          provider.reset();
-          provider.useAsyncFactory = asyncFactory;
-          return this;
-        },
-        value(value: any) {
-          provider.reset();
-          provider.useValue = value;
-          provider.type = ProviderType.VALUE;
-          return this;
-        },
-        class(k: any) {
-          provider.reset();
-          provider.useClass = k;
-          return this;
-        },
-        store() {
-          return provider.store;
-        },
-        inspect() {
-          return provider;
-        },
-        token() {
-          return provider.token as TypeOf;
-        }
-      } as ProviderBuilder<TypeOf, Provider, Pick<Provider, Picked>>
-    );
-  };
-}

package/src/index.ts

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

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

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

@@ -1,29 +0,0 @@
-import {catchError} from "@tsed/core/utils/catchError.js";
-
-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

@@ -1,400 +0,0 @@
-import {levels, Logger} from "@tsed/logger";
-
-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 with initial log level (error) and change the request log level (debug)", () => {
-    const logger = new Logger();
-    logger.level = "error";
-
-    vi.spyOn(logger, "error").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "debug").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "info").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "warn").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "trace").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "fatal").mockReturnValue(undefined as never);
-
-    const contextLogger = new ContextLogger({
-      event: {
-        request: {},
-        response: {}
-      },
-      logger,
-      id: "id",
-      dateStart: new Date("2019-01-01")
-    });
-
-    expect(logger.level).toEqual("ERROR");
-    expect(contextLogger.level).toEqual(levels().ERROR);
-
-    // WHEN
-    contextLogger.level = levels().DEBUG;
-
-    contextLogger.debug({test: "test"});
-    contextLogger.info({test: "test"});
-    contextLogger.warn({test: "test"});
-    contextLogger.error({test: "test"});
-    contextLogger.fatal({test: "test"});
-    contextLogger.trace({test: "test"});
-
-    contextLogger.flush();
-
-    // THEN
-    expect(logger.level).toEqual("ERROR");
-
-    expect(logger.info).toHaveBeenCalledWith({
-      duration: expect.any(Number),
-      reqId: "id",
-      test: "test",
-      time: expect.any(Date)
-    });
-
-    expect(logger.debug).toHaveBeenCalledWith({
-      duration: expect.any(Number),
-      reqId: "id",
-      test: "test",
-      time: expect.any(Date)
-    });
-    expect(logger.warn).toHaveBeenCalledWith({
-      duration: expect.any(Number),
-      reqId: "id",
-      test: "test",
-      time: expect.any(Date)
-    });
-    expect(logger.error).toHaveBeenCalledWith({
-      duration: expect.any(Number),
-      reqId: "id",
-      test: "test",
-      time: expect.any(Date)
-    });
-    expect(logger.fatal).toHaveBeenCalledWith({
-      duration: expect.any(Number),
-      reqId: "id",
-      test: "test",
-      time: expect.any(Date)
-    });
-  });
-  it("should create a new Context with initial log level (error) and not change the request log level", () => {
-    const logger = new Logger();
-    logger.level = "error";
-
-    vi.spyOn(logger, "error").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "debug").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "info").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "warn").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "trace").mockReturnValue(undefined as never);
-    vi.spyOn(logger, "fatal").mockReturnValue(undefined as never);
-
-    const contextLogger = new ContextLogger({
-      event: {
-        request: {},
-        response: {}
-      },
-      logger,
-      id: "id",
-      dateStart: new Date("2019-01-01")
-    });
-
-    expect(contextLogger.level).toEqual(levels().ERROR);
-
-    // WHEN
-    contextLogger.debug({test: "test"});
-    contextLogger.info({test: "test"});
-    contextLogger.warn({test: "test"});
-    contextLogger.error({test: "test"});
-    contextLogger.fatal({test: "test"});
-    contextLogger.trace({test: "test"});
-
-    contextLogger.flush();
-
-    // THEN
-    expect(logger.debug).not.toHaveBeenCalled();
-    expect(logger.trace).not.toHaveBeenCalled();
-    expect(logger.info).not.toHaveBeenCalled();
-    expect(logger.error).toHaveBeenCalledWith({
-      duration: expect.any(Number),
-      reqId: "id",
-      test: "test",
-      time: expect.any(Date)
-    });
-    expect(logger.fatal).toHaveBeenCalledWith({
-      duration: expect.any(Number),
-      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();
-  });
-});