@tsed/platform-http 8.0.1 → 8.0.3

package/src/common/services/PlatformAdapter.ts

@@ -0,0 +1,89 @@
+import {Type} from "@tsed/core";
+import {injectable, ProviderOpts} from "@tsed/di";
+import {PlatformHandlerMetadata, PlatformLayer} from "@tsed/platform-router";
+import {IncomingMessage, ServerResponse} from "http";
+
+import {PlatformMulter, PlatformMulterSettings} from "../config/interfaces/PlatformMulterSettings.js";
+import {PlatformStaticsOptions} from "../config/interfaces/PlatformStaticsSettings.js";
+import {application} from "../fn/application.js";
+import {createHttpServer} from "../utils/createHttpServer.js";
+import {createHttpsServer} from "../utils/createHttpsServer.js";
+import {CreateServerReturn} from "../utils/createServer.js";
+import type {PlatformApplication} from "./PlatformApplication.js";
+
+export abstract class PlatformAdapter<App = TsED.Application> {
+  abstract readonly NAME: string;
+  /**
+   * Load providers in top priority
+   */
+  providers: ProviderOpts[] = [];
+
+  get app(): PlatformApplication<App> {
+    return application();
+  }
+
+  getServers(): CreateServerReturn[] {
+    const app = application<App>();
+    return [createHttpServer(app.callback()), createHttpsServer(app.callback())].filter(Boolean) as any[];
+  }
+
+  onInit(): Promise<void> | void {
+    return Promise.resolve();
+  }
+
+  beforeLoadRoutes(): Promise<void> | void {
+    return Promise.resolve();
+  }
+
+  afterLoadRoutes(): Promise<void> | void {
+    return Promise.resolve();
+  }
+
+  /**
+   * create initial context
+   */
+  abstract useContext(): any;
+
+  /**
+   * Map router layer to the targeted framework
+   */
+  abstract mapLayers(layer: PlatformLayer[]): void;
+
+  /**
+   * Map handler to the targeted framework
+   */
+  mapHandler(handler: Function, layer: PlatformHandlerMetadata): Function {
+    return handler;
+  }
+
+  /**
+   * Return the app instance
+   */
+  abstract createApp(): {app: App; callback(): (req: IncomingMessage, res: ServerResponse) => void};
+
+  /**
+   * Return the statics middlewares
+   * @param endpoint
+   * @param options
+   */
+  abstract statics(endpoint: string, options: PlatformStaticsOptions): any;
+
+  /**
+   * Return the multipart middleware
+   * @param options
+   */
+  abstract multipart(options: PlatformMulterSettings): PlatformMulter;
+
+  /**
+   * Return the body parser for the given
+   * @param type
+   * @param opts
+   */
+  abstract bodyParser(type: string, opts?: Record<string, any>): any;
+}
+
+export interface PlatformBuilderSettings<App = TsED.Application> extends Partial<TsED.Configuration> {
+  adapter?: Type<PlatformAdapter<App>>;
+}
+
+injectable(PlatformAdapter).alias("PlatformAdapter");

package/src/common/services/PlatformApplication.spec.ts

@@ -0,0 +1,101 @@
+import {configuration} from "@tsed/di";
+
+import {PlatformTest} from "../../testing/PlatformTest.js";
+import {createContext} from "../utils/createContext.js";
+import {PlatformApplication} from "./PlatformApplication.js";
+import {PlatformHandler} from "./PlatformHandler.js";
+
+vi.mock("../utils/createContext");
+
+function createDriver() {
+  return {
+    use: vi.fn(),
+    all: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+    patch: vi.fn(),
+    head: vi.fn(),
+    options: vi.fn()
+  };
+}
+
+async function getPlatformApp() {
+  const platformHandler = {
+    createHandler: vi.fn().mockImplementation((o) => o)
+  };
+  const platformApp = await PlatformTest.invoke<PlatformApplication<any>>(PlatformApplication, [
+    {
+      token: PlatformHandler,
+      use: platformHandler
+    }
+  ]);
+  configuration().logger = {};
+  platformApp.rawApp = createDriver() as any;
+  vi.spyOn(platformApp, "multer").mockReturnValue({} as never);
+
+  return {platformApp, platformHandler};
+}
+
+describe("PlatformApplication", () => {
+  beforeEach(PlatformTest.create);
+  afterEach(PlatformTest.reset);
+
+  describe("getApp()", () => {
+    it("should return app", async () => {
+      // GIVEN
+      const {platformApp} = await getPlatformApp();
+
+      // WHEN
+      expect(platformApp.getApp()).toEqual(platformApp.rawApp);
+    });
+  });
+
+  describe("statics()", () => {
+    it("should call statics", async () => {
+      // GIVEN
+      const {platformApp} = await getPlatformApp();
+
+      vi.spyOn(console, "warn");
+
+      // WHEN
+      platformApp.statics("/", {root: "/root"});
+    });
+  });
+  describe("multer()", () => {
+    it("should call statics", async () => {
+      // GIVEN
+      const {platformApp} = await getPlatformApp();
+
+      vi.spyOn(console, "warn");
+
+      // WHEN
+      platformApp.multer({});
+    });
+  });
+
+  describe("callback()", () => {
+    it("should return the callback", async () => {
+      const $ctx = {
+        runInContext: vi.fn().mockImplementation((cb) => {
+          cb();
+        })
+      };
+
+      const {platformApp} = await getPlatformApp();
+
+      (createContext as any).mockReturnValue(() => Promise.resolve($ctx));
+
+      // WHEN
+      const callback = vi.fn();
+
+      vi.spyOn(platformApp, "rawCallback").mockReturnValue(callback);
+
+      await platformApp.callback({} as any, {} as any);
+
+      expect(platformApp.rawCallback).toHaveBeenCalledWith();
+      expect(callback).toHaveBeenCalledWith({}, {});
+    });
+  });
+});

package/src/common/services/PlatformApplication.ts

@@ -0,0 +1,54 @@
+import {inject, injectable, ProviderScope} from "@tsed/di";
+import {PlatformRouter} from "@tsed/platform-router";
+import {IncomingMessage, ServerResponse} from "http";
+
+import {PlatformMulterSettings} from "../config/interfaces/PlatformMulterSettings.js";
+import {PlatformAdapter} from "./PlatformAdapter.js";
+
+declare global {
+  namespace TsED {
+    // @ts-ignore
+    export interface Application {}
+  }
+}
+
+/**
+ * `PlatformApplication` is used to provide all routes collected by annotation `@Controller`.
+ *
+ * @platform
+ */
+export class PlatformApplication<App = TsED.Application> extends PlatformRouter {
+  adapter: PlatformAdapter<App> = inject(PlatformAdapter<App>);
+
+  rawApp: App;
+  rawCallback: () => any;
+
+  constructor() {
+    super();
+
+    const {app, callback} = this.adapter.createApp();
+
+    this.rawApp = app;
+    this.rawCallback = callback;
+  }
+
+  getApp(): App {
+    return this.rawApp;
+  }
+
+  multer(options: PlatformMulterSettings) {
+    return this.adapter.multipart(options);
+  }
+
+  callback(): (req: IncomingMessage, res: ServerResponse) => any;
+  callback(req: IncomingMessage, res: ServerResponse): any;
+  callback(req?: IncomingMessage, res?: ServerResponse) {
+    if (req && res) {
+      return this.callback()(req, res);
+    }
+
+    return this.rawCallback();
+  }
+}
+
+injectable(PlatformApplication).scope(ProviderScope.SINGLETON).alias("PlatformApplication");

package/src/common/services/PlatformHandler.spec.ts

@@ -0,0 +1,152 @@
+import {Injectable, runInContext} from "@tsed/di";
+import {PlatformHandlerMetadata, PlatformHandlerType} from "@tsed/platform-router";
+import {EndpointMetadata, Get, View} from "@tsed/schema";
+
+import {PlatformTest} from "../../testing/PlatformTest.js";
+import {PlatformHandler} from "./PlatformHandler.js";
+
+function getServiceFixture() {
+  const service = PlatformTest.get<PlatformHandler>(PlatformHandler);
+  return {service};
+}
+
+describe("PlatformHandler", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.create());
+
+  describe("createHandler()", () => {
+    it("should create handler", async () => {
+      const {service} = getServiceFixture();
+      const handler = vi.fn();
+      const metadata = new PlatformHandlerMetadata({
+        handler,
+        type: PlatformHandlerType.CTX_FN
+      });
+
+      const $ctx = PlatformTest.createRequestContext();
+
+      const result = service.createHandler(metadata);
+
+      expect(typeof result).toEqual("function");
+
+      await result($ctx);
+
+      expect(handler).toHaveBeenCalledWith($ctx);
+    });
+    it("should create handler from provider", async () => {
+      const {service} = getServiceFixture();
+
+      @Injectable()
+      class Test {
+        @Get("/")
+        get() {
+          return "test";
+        }
+      }
+
+      PlatformTest.injector.addProvider(Test);
+
+      const metadata = new PlatformHandlerMetadata({
+        provider: PlatformTest.injector.getProvider(Test),
+        propertyKey: "get",
+        type: PlatformHandlerType.ENDPOINT
+      });
+
+      const $ctx = PlatformTest.createRequestContext();
+      $ctx.endpoint = EndpointMetadata.get(Test, "get");
+
+      const result = service.createHandler(metadata);
+
+      expect(typeof result).toEqual("function");
+
+      await result($ctx);
+
+      expect($ctx.data).toEqual("test");
+    });
+  });
+  describe("createCustomHandler()", () => {
+    it("should create handler", async () => {
+      @Injectable()
+      class TestService {
+        @View("test")
+        use() {
+          return Promise.resolve("hello");
+        }
+      }
+
+      const {service} = getServiceFixture();
+
+      const $ctx = PlatformTest.createRequestContext();
+      const testService = await PlatformTest.invoke<TestService>(TestService)!;
+      const provider = PlatformTest.injector.getProvider(TestService)!;
+
+      vi.spyOn(testService, "use").mockResolvedValue("hello");
+
+      const result = service.createCustomHandler(provider, "use");
+
+      expect(result).toBeInstanceOf(Function);
+
+      await runInContext($ctx, () => result($ctx));
+
+      expect($ctx.data).toEqual("hello");
+      expect(testService.use).toHaveBeenCalledWith($ctx);
+    });
+  });
+  describe("onRequest()", () => {
+    it("should do nothing when the request is done", async () => {
+      const {service} = getServiceFixture();
+      const handler = vi.fn();
+
+      const $ctx = PlatformTest.createRequestContext();
+      $ctx.next = vi.fn();
+
+      await $ctx.finish();
+
+      $ctx.handlerMetadata = new PlatformHandlerMetadata({
+        handler
+      });
+
+      await service.onRequest(handler, $ctx);
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+    it("should apply headers and status", async () => {
+      @Injectable()
+      class TestService {
+        @Get("/")
+        use() {
+          return Promise.resolve("hello");
+        }
+      }
+
+      const {service} = getServiceFixture();
+      const handler = vi.fn().mockResolvedValue({
+        status: 201,
+        statusText: "CREATED",
+        headers: {
+          test: "test"
+        },
+        data: "data"
+      });
+
+      const $ctx = PlatformTest.createRequestContext();
+      $ctx.next = vi.fn();
+      $ctx.endpoint = EndpointMetadata.get(TestService, "use");
+
+      $ctx.handlerMetadata = new PlatformHandlerMetadata({
+        handler: TestService.prototype.use
+      });
+
+      vi.spyOn(service, "flush").mockResolvedValue();
+
+      await service.onRequest(handler, $ctx);
+
+      expect(handler).toHaveBeenCalled();
+      expect($ctx.response.statusCode).toEqual(201);
+      expect($ctx.response.getHeaders()).toEqual({
+        test: "test",
+        "x-request-id": "id"
+      });
+    });
+  });
+});

package/src/common/services/PlatformHandler.ts

@@ -0,0 +1,140 @@
+import {AnyPromiseResult, AnyToPromiseStatus, catchAsyncError} from "@tsed/core";
+import {inject, injectable, Provider, ProviderScope} from "@tsed/di";
+import {PlatformExceptions} from "@tsed/platform-exceptions";
+import {PlatformParams, PlatformParamsCallback} from "@tsed/platform-params";
+import {PlatformResponseFilter} from "@tsed/platform-response-filter";
+import {
+  AlterEndpointHandlersArg,
+  PlatformHandlerMetadata,
+  PlatformHandlerType,
+  PlatformRouters,
+  useResponseHandler
+} from "@tsed/platform-router";
+import {JsonOperationRoute} from "@tsed/schema";
+
+import {AnyToPromiseWithCtx} from "../domain/AnyToPromiseWithCtx.js";
+import {PlatformContext} from "../domain/PlatformContext.js";
+import {setResponseHeaders} from "../utils/setResponseHeaders.js";
+import {PlatformApplication} from "./PlatformApplication.js";
+import {PlatformMiddlewaresChain} from "./PlatformMiddlewaresChain.js";
+
+/**
+ * Platform Handler abstraction layer. Wrap original class method to a pure platform handler (Express, Koa, etc...).
+ * @platform
+ */
+export class PlatformHandler {
+  protected responseFilter = inject(PlatformResponseFilter);
+  protected platformParams = inject(PlatformParams);
+  protected platformExceptions = inject(PlatformExceptions);
+  protected platformApplication = inject(PlatformApplication);
+  protected platformMiddlewaresChain = inject(PlatformMiddlewaresChain);
+  protected platformRouters = inject(PlatformRouters);
+
+  constructor() {
+    // configure the router module
+    this.platformRouters.hooks
+      .on("alterEndpointHandlers", (handlers: AlterEndpointHandlersArg, operationRoute: JsonOperationRoute) => {
+        handlers = this.platformMiddlewaresChain.get(handlers, operationRoute);
+
+        handlers.after.push(useResponseHandler(this.flush.bind(this)));
+
+        return handlers;
+      })
+      .on("alterHandler", (handlerMetadata: PlatformHandlerMetadata) => {
+        const handler = handlerMetadata.isInjectable() ? this.createHandler(handlerMetadata) : handlerMetadata.handler;
+
+        return this.platformApplication.adapter.mapHandler(handler, handlerMetadata);
+      });
+  }
+
+  createHandler(handlerMetadata: PlatformHandlerMetadata): any {
+    const handler = this.platformParams.compileHandler(handlerMetadata);
+
+    return ($ctx: PlatformContext) => {
+      $ctx.handlerMetadata = handlerMetadata;
+
+      return this.onRequest(handler, $ctx);
+    };
+  }
+
+  /**
+   * @param provider
+   * @param propertyKey
+   */
+  createCustomHandler(provider: Provider, propertyKey: string) {
+    const metadata = new PlatformHandlerMetadata({
+      provider,
+      type: PlatformHandlerType.CUSTOM,
+      propertyKey
+    });
+
+    return this.createHandler(metadata);
+  }
+
+  /**
+   * Call handler when a request his handle
+   */
+  async onRequest(handler: PlatformParamsCallback, $ctx: PlatformContext) {
+    const {handlerMetadata} = $ctx;
+
+    if (handlerMetadata.type === PlatformHandlerType.CTX_FN) {
+      return handler({$ctx});
+    }
+
+    const resolver = new AnyToPromiseWithCtx($ctx);
+
+    const response = await resolver.call(handler);
+    // Note: restore previous handler metadata (for OIDC)
+    $ctx.handlerMetadata = handlerMetadata;
+
+    if (response.state === AnyToPromiseStatus.RESOLVED && !$ctx.isDone()) {
+      return this.onResponse(response, $ctx);
+    }
+  }
+
+  onResponse({status, data, headers}: AnyPromiseResult, $ctx: PlatformContext) {
+    if (status) {
+      $ctx.response.status(status);
+    }
+
+    if (headers) {
+      $ctx.response.setHeaders(headers);
+    }
+
+    if (data !== undefined) {
+      $ctx.data = data;
+    }
+
+    $ctx.error = null;
+
+    // set headers each times that an endpoint is called
+    if ($ctx.handlerMetadata.isEndpoint()) {
+      setResponseHeaders($ctx);
+    }
+  }
+
+  /**
+   * Send the response to the consumer.
+   * @protected
+   * @param $ctx
+   */
+  async flush($ctx: PlatformContext) {
+    if (!$ctx.error) {
+      $ctx.error = await catchAsyncError(async () => {
+        const {response} = $ctx;
+
+        if (!$ctx.isDone()) {
+          let data = await this.responseFilter.serialize($ctx.data, $ctx as any);
+          data = await this.responseFilter.transform(data, $ctx as any);
+          response.body(data);
+        }
+      });
+    }
+
+    if ($ctx.error) {
+      this.platformExceptions.catch($ctx.error, $ctx);
+    }
+  }
+}
+
+injectable(PlatformHandler).scope(ProviderScope.SINGLETON);

package/src/common/services/PlatformMiddlewaresChain.spec.ts

@@ -0,0 +1,96 @@
+import {Controller, ControllerProvider} from "@tsed/di";
+import {Middleware, Use, UseAuth} from "@tsed/platform-middlewares";
+import {AcceptMime, All, EndpointMetadata, Get, getOperationsRoutes, Post} from "@tsed/schema";
+
+import {PlatformTest} from "../../testing/PlatformTest.js";
+import {MultipartFile} from "../decorators/multer/multipartFile.js";
+import {PlatformAcceptMimesMiddleware} from "../middlewares/PlatformAcceptMimesMiddleware.js";
+import {PlatformMulterMiddleware} from "../middlewares/PlatformMulterMiddleware.js";
+import {PlatformMiddlewaresChain} from "./PlatformMiddlewaresChain.js";
+
+@Middleware()
+class MyAuthMiddleware {
+  use() {}
+}
+
+@Middleware({
+  priority: -1
+})
+class TokenMiddleware {
+  use() {}
+}
+
+@Controller("/")
+class TestCtrl {
+  @All("/")
+  allMethod() {}
+
+  @Get("/")
+  getMethod() {}
+
+  @Use("/")
+  use() {}
+
+  @Use()
+  use2() {}
+
+  @Post("/file")
+  @UseAuth(MyAuthMiddleware, {scope: "admin"})
+  @Use(TokenMiddleware)
+  @AcceptMime("application/json")
+  authEndpoint(@MultipartFile("file") file: MultipartFile) {}
+}
+
+function parentControllerBefore() {}
+
+function getFixture() {
+  const provider = PlatformTest.injector.getProvider<ControllerProvider>(TestCtrl)!;
+  const platformMiddlewaresChain = PlatformTest.get<PlatformMiddlewaresChain>(PlatformMiddlewaresChain);
+  const operationRoutes = getOperationsRoutes<EndpointMetadata>(provider.token);
+  return {platformMiddlewaresChain, operationRoutes, provider};
+}
+
+describe("PlatformMiddlewaresChain", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+
+  it("should return the middlewares for a given endpoint (getMethod)", () => {
+    const {platformMiddlewaresChain, operationRoutes} = getFixture();
+    const parentsMiddlewares = {
+      before: [parentControllerBefore]
+    };
+
+    const chain = platformMiddlewaresChain.get(parentsMiddlewares as any, operationRoutes[1]);
+
+    expect(chain.before[0]).toEqual(parentControllerBefore);
+  });
+  it("should return the middlewares for a given endpoint (allMethod)", () => {
+    const {platformMiddlewaresChain, operationRoutes} = getFixture();
+
+    const parentsMiddlewares: any = {
+      before: [parentControllerBefore]
+    };
+
+    const chain = platformMiddlewaresChain.get(parentsMiddlewares, operationRoutes[1]);
+
+    expect(chain.before[0]).toEqual(parentControllerBefore);
+  });
+
+  it("should merge middlewares and sort middleware by priority", () => {
+    const {platformMiddlewaresChain, operationRoutes} = getFixture();
+
+    const parentsMiddlewares: any = {
+      before: [parentControllerBefore, MyAuthMiddleware, TokenMiddleware]
+    };
+
+    const chain = platformMiddlewaresChain.get(parentsMiddlewares, operationRoutes[3]);
+
+    expect(chain.before).toEqual([
+      PlatformAcceptMimesMiddleware,
+      parentControllerBefore,
+      MyAuthMiddleware,
+      TokenMiddleware,
+      PlatformMulterMiddleware
+    ]);
+  });
+});

package/src/common/services/PlatformMiddlewaresChain.ts

@@ -0,0 +1,55 @@
+import {isClass} from "@tsed/core";
+import {constant, inject, injectable} from "@tsed/di";
+import {ParamTypes} from "@tsed/platform-params";
+import {AlterEndpointHandlersArg} from "@tsed/platform-router";
+import {JsonEntityStore, JsonOperationRoute} from "@tsed/schema";
+
+import {PlatformAcceptMimesMiddleware} from "../middlewares/PlatformAcceptMimesMiddleware.js";
+import {PlatformMulterMiddleware} from "../middlewares/PlatformMulterMiddleware.js";
+import {PlatformAdapter} from "./PlatformAdapter.js";
+
+export class PlatformMiddlewaresChain {
+  protected acceptMimes = constant<string[]>("acceptMimes", []);
+  protected adapter = inject(PlatformAdapter);
+
+  get(handlers: AlterEndpointHandlersArg, operationRoute: JsonOperationRoute): AlterEndpointHandlersArg {
+    const {ACCEPT_MIMES, FILE} = this.getParamTypes(handlers, operationRoute);
+
+    return {
+      ...handlers,
+      before: [ACCEPT_MIMES && PlatformAcceptMimesMiddleware, ...handlers.before, FILE && PlatformMulterMiddleware].filter(Boolean) as any[]
+    };
+  }
+
+  protected hasAcceptMimes(operationRoute: JsonOperationRoute) {
+    return operationRoute.endpoint.acceptMimes.length || this.acceptMimes.length;
+  }
+
+  protected getParamTypes(middlewares: AlterEndpointHandlersArg, operationRoute: JsonOperationRoute) {
+    return middlewares.before
+      .concat(middlewares.after)
+      .filter(isClass)
+      .reduce(
+        (paramTypes, token) => {
+          const entity = JsonEntityStore.fromMethod(token, "use");
+
+          if (entity.decoratorType === "method") {
+            const {FILE, RAW_BODY, BODY} = entity.getParamTypes();
+            paramTypes.FILE = paramTypes.FILE || FILE;
+            paramTypes.RAW_BODY = paramTypes.RAW_BODY || RAW_BODY;
+            paramTypes.BODY = paramTypes.BODY || BODY;
+          }
+
+          return paramTypes;
+        },
+        {
+          ACCEPT_MIMES: this.hasAcceptMimes(operationRoute),
+          FILE: operationRoute.has(ParamTypes.FILES),
+          RAW_BODY: operationRoute.has(ParamTypes.RAW_BODY),
+          BODY: operationRoute.has(ParamTypes.BODY) || operationRoute.method === "ALL"
+        }
+      );
+  }
+}
+
+injectable(PlatformMiddlewaresChain);