@tsed/platform-http 8.0.0 → 8.0.2

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

@@ -0,0 +1,40 @@
+import {nameOf} from "@tsed/core";
+
+import {Controller} from "../../../../../di/src/common/decorators/controller.js";
+import {M1Ctrl1} from "../../../../../di/src/common/utils/__mock__/module1/controllers/M1Ctrl1.js";
+import {Module1} from "../../../../../di/src/common/utils/__mock__/module1/Module1.js";
+import {M2Ctrl} from "../../../../../di/src/common/utils/__mock__/module2/controllers/M2Ctrl.js";
+import {Module2} from "../../../../../di/src/common/utils/__mock__/module2/Module2.js";
+import {resolveControllers} from "./resolveControllers.js";
+
+@Controller("/root")
+class TestCtrl {}
+
+describe("resolveControllers", () => {
+  it("should load providers and merge configuration", () => {
+    const configuration = {
+      mount: {
+        "/rest": [TestCtrl]
+      },
+      imports: [Module1, Module2]
+    };
+
+    const result = resolveControllers(configuration);
+    const routes = result.map((item) => ({...item, token: nameOf(item.token)}));
+
+    expect(routes).toEqual([
+      {
+        route: "/m1",
+        token: "M1Ctrl1"
+      },
+      {
+        route: "/mod2",
+        token: "M2Ctrl"
+      },
+      {
+        route: "/rest",
+        token: "TestCtrl"
+      }
+    ]);
+  });
+});

package/src/common/utils/resolveControllers.ts

@@ -0,0 +1,54 @@
+import {isArray, isClass} from "@tsed/core";
+import {GlobalProviders, Provider, ProviderType, type TokenProvider, type TokenRoute} from "@tsed/di";
+
+const lookupProperties = ["mount", "imports"];
+
+/**
+ * @ignore
+ */
+function getTokens(config: any): {route?: string; token: TokenProvider}[] {
+  if (!config) {
+    return [];
+  }
+
+  if (isArray(config)) {
+    return config.filter(isClass).map((value: any) => {
+      return {token: value};
+    });
+  }
+
+  return Object.keys(config).reduce((list: any[], route: string) => {
+    return [
+      ...list,
+      ...[]
+        .concat(config[route])
+        .filter(isClass)
+        .map((token) => ({
+          route,
+          token
+        }))
+    ];
+  }, []);
+}
+
+/**
+ * @ignore
+ */
+function resolveRecursively(providers: {token: TokenProvider; route?: string}[]) {
+  return providers
+    .map(({token}) => GlobalProviders.get(token))
+    .filter((provider) => provider?.type === ProviderType.MODULE && provider.configuration)
+    .flatMap((provider: Provider) => resolveControllers(provider.configuration));
+}
+
+/**
+ * Return controllers and is base route according to his configuration in module configuration.
+ *
+ * @param settings
+ * @ignore
+ */
+export function resolveControllers(settings: Partial<TsED.Configuration>): TokenRoute[] {
+  const providers = lookupProperties.flatMap((property) => getTokens(settings[property]));
+
+  return [...resolveRecursively(providers), ...providers].filter((provider) => !!provider.route) as any[];
+}

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

@@ -0,0 +1,84 @@
+import {EndpointMetadata, Get, Redirect, Returns} from "@tsed/schema";
+
+import {PlatformTest} from "../../testing/PlatformTest.js";
+import {setResponseHeaders} from "./setResponseHeaders.js";
+
+describe("setResponseHeaders", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+
+  it("should set headers, status and contentType", async () => {
+    class Test {
+      @Get("/")
+      @(Returns(200).Header("x-header", "test"))
+      test() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+    // WHEN
+    await setResponseHeaders(ctx);
+
+    // THEN
+    expect(ctx.response.getHeaders()).toEqual({"x-request-id": "id", "x-header": "test"});
+    expect(ctx.response.statusCode).toEqual(200);
+  });
+  it("should not set headers automatically if the value isn't declared", async () => {
+    class Test {
+      @Get("/")
+      @(Returns(200).Header("x-header"))
+      test() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+    // WHEN
+    await setResponseHeaders(ctx);
+
+    // THEN
+    expect(ctx.response.getHeaders()).toEqual({"x-request-id": "id"});
+    expect(ctx.response.statusCode).toEqual(200);
+  });
+
+  it("should redirect", async () => {
+    class Test {
+      @Get("/")
+      @Redirect(301, "/path")
+      test() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+    vi.spyOn(ctx.response, "redirect").mockReturnValue(undefined as any);
+
+    // WHEN
+    await setResponseHeaders(ctx);
+
+    // THEN
+    expect(ctx.response.redirect).toHaveBeenCalledWith(301, "/path");
+  });
+
+  it("should do nothing when headers is already sent", async () => {
+    class Test {
+      @Get("/")
+      @(Returns(200).Header("x-header", "test"))
+      test() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.response.raw.headersSent = true;
+
+    ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+    vi.spyOn(ctx.response.raw, "set");
+
+    // WHEN
+    await setResponseHeaders(ctx);
+
+    // THEN
+    return expect(ctx.response.raw.set).not.toHaveBeenCalled();
+  });
+});

package/src/common/utils/setResponseHeaders.ts

@@ -0,0 +1,31 @@
+import {PlatformContext} from "../domain/PlatformContext.js";
+
+/**
+ * @ignore
+ */
+export function setResponseHeaders(ctx: PlatformContext) {
+  const {response, endpoint} = ctx;
+  const {operation} = endpoint;
+
+  if (ctx.isDone()) {
+    return;
+  }
+
+  if (!response.hasStatus()) {
+    // apply status only if the isn't already modified
+    response.status(operation.getStatus());
+  }
+
+  const statusCode = response.statusCode;
+  const headers = operation.getHeadersOf(statusCode);
+
+  Object.entries(headers).forEach(([key, item]: any[]) => {
+    if (!response.get(key) && item.example !== undefined) {
+      response.setHeader(key, String(item.example));
+    }
+  });
+
+  if (operation.isRedirection(statusCode)) {
+    response.redirect(statusCode, response.get("location"));
+  }
+}

package/src/index.ts

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

package/src/testing/FakeAdapter.ts

@@ -0,0 +1,69 @@
+import {injectable, type ProviderOpts} from "@tsed/di";
+import {type PlatformContextHandler, PlatformLayer} from "@tsed/platform-router";
+
+import {
+  PlatformAdapter,
+  PlatformContext,
+  type PlatformMulter,
+  type PlatformMulterSettings,
+  type PlatformStaticsOptions
+} from "../common/index.js";
+
+export class FakeAdapter extends PlatformAdapter<any> {
+  readonly NAME: string = "FAKE_ADAPTER";
+  providers: ProviderOpts[] = [];
+
+  static createFakeRawDriver() {
+    // istanbul ignore next
+    function FakeRawDriver() {}
+
+    // istanbul ignore next
+    function use() {
+      return this;
+    }
+
+    FakeRawDriver.use = use;
+    FakeRawDriver.all = use;
+    FakeRawDriver.get = use;
+    FakeRawDriver.patch = use;
+    FakeRawDriver.post = use;
+    FakeRawDriver.put = use;
+    FakeRawDriver.head = use;
+    FakeRawDriver.delete = use;
+    FakeRawDriver.options = use;
+
+    return FakeRawDriver;
+  }
+
+  createApp(): {app: any; callback(): any} {
+    const app = FakeAdapter.createFakeRawDriver();
+    return {
+      app,
+      callback() {
+        return app;
+      }
+    };
+  }
+
+  multipart(options: PlatformMulterSettings): PlatformMulter {
+    return {} as any;
+  }
+
+  statics(endpoint: string, options: PlatformStaticsOptions): any {
+    return {};
+  }
+
+  bodyParser(type: string): any {
+    return () => {};
+  }
+
+  mapLayers(layers: PlatformLayer[]) {}
+
+  mapHandler(handler: PlatformContextHandler<PlatformContext>) {
+    return handler;
+  }
+
+  useContext() {}
+}
+
+injectable(PlatformAdapter).class(FakeAdapter);

package/src/testing/FakeResponse.ts

@@ -0,0 +1,72 @@
+import {EventEmitter} from "node:events";
+
+export class FakeResponse extends EventEmitter {
+  headers: Record<string, unknown> = {};
+  locals: Record<string, unknown> = {};
+  statusCode: number = 200;
+  data: any;
+
+  constructor(opts = {}) {
+    super();
+
+    Object.assign(this, opts);
+  }
+
+  status(code: number) {
+    this.statusCode = code;
+    return this;
+  }
+
+  contentType(content: string) {
+    this.set("content-type", content);
+  }
+
+  contentLength(content: number) {
+    this.set("content-length", content);
+  }
+
+  redirect(status: number, path: string) {
+    this.statusCode = status;
+    this.set("location", path);
+  }
+
+  location(path: string) {
+    this.set("location", path);
+  }
+
+  get(key: string) {
+    return this.headers[key.toLowerCase()];
+  }
+
+  getHeaders() {
+    return this.headers;
+  }
+
+  set(key: string, value: any) {
+    this.headers[key.toLowerCase()] = value;
+    return this;
+  }
+
+  setHeader(key: string, value: any) {
+    this.headers[key.toLowerCase()] = value;
+    return this;
+  }
+
+  send(data: any) {
+    this.data = data;
+  }
+
+  json(data: any) {
+    this.data = data;
+  }
+
+  write(chunk: any) {
+    this.emit("data", chunk);
+  }
+
+  end(data: any) {
+    data !== undefined && (this.data = data);
+
+    this.emit("end");
+  }
+}

package/src/testing/PlatformTest.spec.ts

@@ -0,0 +1,53 @@
+import {Configuration, Controller, InjectorService} from "@tsed/di";
+import {Get} from "@tsed/schema";
+
+import {PlatformContext} from "../common/domain/PlatformContext.js";
+import {PlatformTest} from "./PlatformTest.js";
+
+@Configuration({})
+class Server {}
+
+@Controller("/")
+class MyController {
+  @Get("/")
+  get() {
+    return "hello";
+  }
+}
+
+describe("PlatformTest", () => {
+  let testContext: any;
+
+  beforeEach(() => {
+    testContext = {};
+  });
+
+  beforeEach(PlatformTest.create);
+  afterEach(PlatformTest.reset);
+
+  it("should get symbol from injector", () => {
+    expect(PlatformTest.get(InjectorService)).toBeInstanceOf(InjectorService);
+  });
+
+  describe("createRequestContext", () => {
+    it("should return request context", () => {
+      expect(PlatformTest.createRequestContext()).toBeInstanceOf(PlatformContext);
+    });
+  });
+
+  describe("invoke", () => {
+    it("should return request context", async () => {
+      class Test {
+        called: boolean;
+
+        $onInit() {
+          this.called = true;
+
+          return Promise.resolve();
+        }
+      }
+
+      expect(await PlatformTest.invoke(Test)).toEqual({called: true});
+    });
+  });
+});

package/src/testing/PlatformTest.ts

@@ -0,0 +1,157 @@
+import {DITest, injector, InjectorService} from "@tsed/di";
+import accepts from "accepts";
+import type {IncomingMessage, RequestListener, ServerResponse} from "http";
+
+import {PlatformBuilder} from "../common/builder/PlatformBuilder.js";
+import {PlatformContext, PlatformContextOptions} from "../common/domain/PlatformContext.js";
+import {PlatformAdapter, PlatformBuilderSettings} from "../common/services/PlatformAdapter.js";
+import {PlatformApplication} from "../common/services/PlatformApplication.js";
+import {createInjector} from "../common/utils/createInjector.js";
+import {getConfiguration} from "../common/utils/getConfiguration.js";
+import {FakeAdapter} from "./FakeAdapter.js";
+import {FakeResponse} from "./FakeResponse.js";
+
+/**
+ * @platform
+ */
+export class PlatformTest extends DITest {
+  static async create(settings: Partial<TsED.Configuration> = {}) {
+    settings.imports = [
+      {
+        token: PlatformAdapter,
+        useClass: FakeAdapter
+      },
+      ...(settings.imports || [])
+    ];
+
+    PlatformTest.createInjector(getConfiguration(settings));
+    await DITest.createContainer();
+  }
+
+  /**
+   * Create a new injector with the right default services
+   */
+  static createInjector(settings: any = {}): InjectorService {
+    return createInjector(DITest.configure({httpPort: false, httpsPort: false, ...settings}));
+  }
+
+  /**
+   * Load the server silently without listening port and configure it on test profile.
+   * @decorator
+   * @param mod
+   * @param listen
+   * @param settings
+   * @returns {Promise<void>}
+   */
+  static bootstrap(
+    mod: any,
+    {
+      listen,
+      ...settings
+    }: Partial<
+      PlatformBuilderSettings & {
+        listen: boolean;
+      }
+    > = {}
+  ): () => Promise<void> {
+    return async function before(): Promise<void> {
+      let instance: PlatformBuilder;
+      // @ts-ignore
+      settings = DITest.configure(settings);
+
+      const configuration = getConfiguration(settings, mod);
+
+      instance = await PlatformBuilder.build(mod, configuration).bootstrap();
+
+      await instance.listen(!!listen);
+    };
+  }
+
+  /**
+   * It injects services into the test function where you can alter, spy on, and manipulate them.
+   *
+   * The inject function has two parameters
+   *
+   * * an array of Service dependency injection tokens,
+   * * a test function whose parameters correspond exactly to each item in the injection token array.
+   *
+   * @deprecated use PlatformTest.injector.invoke instead
+   * @param targets
+   * @param func
+   */
+  static inject<T>(targets: any[], func: (...args: any[]) => Promise<T> | T): () => Promise<T> {
+    return async (): Promise<T> => {
+      await PlatformTest.create();
+
+      const inj: InjectorService = injector();
+      const deps = [];
+
+      for (const target of targets) {
+        deps.push(inj.has(target) ? inj.get(target) : await inj.invoke(target));
+      }
+
+      return func(...deps);
+    };
+  }
+
+  /**
+   * Return the raw application (express or koa).
+   * Use this callback with SuperTest.
+   *
+   * ```typescript
+   * let request: SuperTest.Agent;
+   * beforeEach(PlatformTest.bootstrap(Server, {
+   *   mount: {
+   *     "/rest": [ProductsController]
+   *   }
+   * }));
+   * beforeEach(() => {
+   *   request = SuperTest(PlatformTest.callback());
+   * });
+   * ```
+   */
+  static callback(): RequestListener<typeof IncomingMessage, typeof ServerResponse> {
+    return injector().get<PlatformApplication>(PlatformApplication)?.callback() as any;
+  }
+
+  static createRequest(options: any = {}): any {
+    return {
+      headers: {},
+      method: "GET",
+      url: "/",
+      query: {},
+      get(key: string) {
+        return this.headers[key.toLowerCase()];
+      },
+      accepts(mime?: string | string[]) {
+        return accepts(this).types([].concat(mime as never));
+      },
+      ...options
+    };
+  }
+
+  static createResponse(options: any = {}): any {
+    return new FakeResponse(options);
+  }
+
+  static createRequestContext(options: Partial<PlatformContextOptions & any> = {}) {
+    const event = {
+      ...options.event,
+      request: options?.request?.request || options?.event?.request || PlatformTest.createRequest(),
+      response: options?.response?.response || options?.event?.response || PlatformTest.createResponse()
+    };
+
+    const $ctx = new PlatformContext({
+      id: "id",
+      url: "/",
+      ...options,
+      event
+    });
+
+    if (options.endpoint) {
+      $ctx.endpoint = options.endpoint;
+    }
+
+    return $ctx;
+  }
+}

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./FakeAdapter.js";
+export * from "./PlatformTest.js";