@tsed/platform-http 8.11.1 → 8.11.2-rc.1

package/src/common/interfaces/IncomingEvent.ts

@@ -1,6 +0,0 @@
-import {IncomingMessage, ServerResponse} from "node:http";
-
-export interface IncomingEvent<Req = IncomingMessage, Res = ServerResponse> extends Record<string, unknown> {
-  response: Res;
-  request: Req;
-}

package/src/common/interfaces/OnReady.ts

@@ -1,3 +0,0 @@
-export interface OnReady {
-  $onReady(): void | Promise<any>;
-}

package/src/common/interfaces/OnRequest.ts

@@ -1,5 +0,0 @@
-import {PlatformContext} from "../domain/PlatformContext.js";
-
-export interface OnRequest {
-  $onRequest(ctx: PlatformContext): void;
-}

package/src/common/interfaces/OnResponse.ts

@@ -1,5 +0,0 @@
-import {PlatformResponse} from "../services/PlatformResponse.js";
-
-export interface OnResponse {
-  $onResponse(ctx: PlatformResponse): void;
-}

package/src/common/interfaces/OnRoutesInit.ts

@@ -1,3 +0,0 @@
-export interface OnRoutesInit {
-  $onRoutesInit(): void | Promise<any>;
-}

package/src/common/interfaces/PlatformRouteOptions.ts

@@ -1,17 +0,0 @@
-import {Type} from "@tsed/core";
-import {PathType} from "@tsed/di";
-
-/**
- * @ignore
- */
-export interface PlatformRouteOptions {
-  token?: Type<any>;
-  path?: PathType | undefined;
-  method?: string;
-  handlers: any[];
-}
-
-/**
- * @ignore
- */
-export type PlatformRouteWithoutHandlers = Partial<Omit<PlatformRouteOptions, "handlers">>;

package/src/common/interfaces/ResponseErrorObject.ts

@@ -1,8 +0,0 @@
-/**
- * Interface can be implemented to customize the error sent to the client.
- */
-export interface ResponseErrorObject extends Error {
-  errors?: Error[] | Error | any;
-  origin?: Error;
-  headers?: {};
-}

package/src/common/interfaces/Route.ts

@@ -1,12 +0,0 @@
-import {Provider, TokenProvider} from "@tsed/di";
-
-export interface Route extends Record<string, any> {
-  route: string;
-  token: TokenProvider;
-}
-
-export interface RouteController {
-  route: string;
-  routes: Set<string>;
-  provider: Provider;
-}

package/src/common/middlewares/PlatformAcceptMimesMiddleware.spec.ts

@@ -1,215 +0,0 @@
-import {catchError} from "@tsed/core";
-import {AcceptMime, EndpointMetadata, Get} from "@tsed/schema";
-
-import {PlatformTest} from "../../testing/index.js";
-import {PlatformAcceptMimesMiddleware} from "./PlatformAcceptMimesMiddleware.js";
-
-describe("PlatformMimesMiddleware", () => {
-  describe("when server has configuration", () => {
-    beforeEach(() =>
-      PlatformTest.create({
-        acceptMimes: ["application/json", "text"]
-      })
-    );
-    afterEach(() => PlatformTest.reset());
-    it("should accept type (application/json)", async () => {
-      class Test {
-        @Get("/")
-        @AcceptMime("application/json")
-        get() {}
-      }
-
-      const endpoint = EndpointMetadata.get(Test, "get");
-      const request = PlatformTest.createRequest({
-        headers: {
-          accept: "application/json"
-        }
-      });
-      const ctx = PlatformTest.createRequestContext({
-        event: {request},
-        endpoint
-      });
-
-      vi.spyOn(request, "accepts");
-
-      const middleware = await PlatformTest.invoke<PlatformAcceptMimesMiddleware>(PlatformAcceptMimesMiddleware);
-
-      middleware.use(ctx as never);
-
-      expect(request.accepts).toHaveBeenCalledWith(["application/json", "text"]);
-    });
-    it("should accept type (text)", async () => {
-      class Test {
-        @Get("/")
-        @AcceptMime("text")
-        get() {}
-      }
-
-      const endpoint = EndpointMetadata.get(Test, "get");
-      const request: any = PlatformTest.createRequest({
-        headers: {
-          accept: "text/*, application/json"
-        }
-      });
-      const ctx = PlatformTest.createRequestContext({
-        event: {request},
-        endpoint
-      });
-
-      vi.spyOn(request, "accepts");
-
-      const middleware = await PlatformTest.invoke<PlatformAcceptMimesMiddleware>(PlatformAcceptMimesMiddleware);
-      middleware.use(ctx as never);
-
-      expect(request.accepts).toHaveBeenCalledWith(["text", "application/json"]);
-    });
-    it("should accept type (text) without endpoint", async () => {
-      class Test {
-        @Get("/")
-        @AcceptMime("text")
-        get() {}
-      }
-
-      const request: any = PlatformTest.createRequest({
-        headers: {
-          accept: "text/*, application/json"
-        }
-      });
-      const ctx = PlatformTest.createRequestContext({
-        event: {request}
-      });
-      vi.spyOn(request, "accepts");
-
-      const middleware = await PlatformTest.invoke<PlatformAcceptMimesMiddleware>(PlatformAcceptMimesMiddleware);
-      middleware.use(ctx as never);
-
-      expect(request.accepts).toHaveBeenCalledWith(["application/json", "text"]);
-    });
-    it("should refuse type", async () => {
-      class Test {
-        @Get("/")
-        @AcceptMime("application/json")
-        get() {}
-      }
-
-      const endpoint = EndpointMetadata.get(Test, "get");
-      const request: any = PlatformTest.createRequest({
-        headers: {
-          accept: "application/xml"
-        }
-      });
-      const ctx = PlatformTest.createRequestContext({
-        event: {request},
-        endpoint
-      });
-      const middleware = await PlatformTest.invoke<PlatformAcceptMimesMiddleware>(PlatformAcceptMimesMiddleware);
-
-      const error: any = catchError(() => middleware.use(ctx as never));
-
-      expect(error.message).toEqual("You must accept content-type application/json, text");
-    });
-  });
-  describe("when server hasn't configuration", () => {
-    beforeEach(() => PlatformTest.create());
-    afterEach(() => PlatformTest.reset());
-    it("should do noting", async () => {
-      class Test {
-        @Get("/")
-        get() {}
-      }
-
-      const endpoint = EndpointMetadata.get(Test, "get");
-      const request: any = PlatformTest.createRequest({
-        headers: {
-          accept: "application/json"
-        }
-      });
-      const ctx = PlatformTest.createRequestContext({
-        event: {request},
-        endpoint
-      });
-      vi.spyOn(request, "accepts");
-
-      const middleware = await PlatformTest.invoke<PlatformAcceptMimesMiddleware>(PlatformAcceptMimesMiddleware);
-      middleware.use(ctx as never);
-
-      return expect(request.accepts).not.toHaveBeenCalled();
-    });
-    it("should accept type (application/json)", async () => {
-      class Test {
-        @Get("/")
-        @AcceptMime("application/json")
-        get() {}
-      }
-
-      const endpoint = EndpointMetadata.get(Test, "get");
-      const request: any = PlatformTest.createRequest({
-        headers: {
-          accept: "application/json"
-        }
-      });
-      const ctx = PlatformTest.createRequestContext({
-        event: {request},
-        endpoint
-      });
-      vi.spyOn(request, "accepts");
-
-      const middleware = await PlatformTest.invoke<PlatformAcceptMimesMiddleware>(PlatformAcceptMimesMiddleware);
-      middleware.use(ctx as never);
-
-      expect(request.accepts).toHaveBeenCalledWith(["application/json"]);
-    });
-    it("should accept type (text)", async () => {
-      class Test {
-        @Get("/")
-        @AcceptMime("text")
-        get() {}
-      }
-
-      const endpoint = EndpointMetadata.get(Test, "get");
-      const request: any = PlatformTest.createRequest({
-        headers: {
-          accept: "text/*, application/json"
-        }
-      });
-      const ctx = PlatformTest.createRequestContext({
-        event: {
-          request
-        },
-        endpoint
-      });
-      vi.spyOn(request, "accepts");
-
-      const middleware = await PlatformTest.invoke<PlatformAcceptMimesMiddleware>(PlatformAcceptMimesMiddleware);
-      middleware.use(ctx as never);
-
-      expect(request.accepts).toHaveBeenCalledWith(["text"]);
-    });
-    it("should refuse type", async () => {
-      class Test {
-        @Get("/")
-        @AcceptMime("application/json")
-        get() {}
-      }
-
-      const endpoint = EndpointMetadata.get(Test, "get");
-      const request: any = PlatformTest.createRequest({
-        headers: {
-          accept: "application/xml"
-        }
-      });
-      const ctx = PlatformTest.createRequestContext({
-        event: {request},
-        endpoint
-      });
-
-      vi.spyOn(request, "accepts");
-
-      const middleware = await PlatformTest.invoke<PlatformAcceptMimesMiddleware>(PlatformAcceptMimesMiddleware);
-
-      const error: any = catchError(() => middleware.use(ctx as never));
-
-      expect(error.message).toEqual("You must accept content-type application/json");
-    });
-  });
-});

package/src/common/middlewares/PlatformAcceptMimesMiddleware.ts

@@ -1,34 +0,0 @@
-import {uniq} from "@tsed/core";
-import {constant, injectable, ProviderType} from "@tsed/di";
-import {NotAcceptable} from "@tsed/exceptions";
-import {MiddlewareMethods} from "@tsed/platform-middlewares";
-import {Context} from "@tsed/platform-params";
-import type {AlterEndpointHandlersArg} from "@tsed/platform-router";
-import type {JsonOperationRoute} from "@tsed/schema";
-
-/**
- * @middleware
- * @platform
- */
-export class PlatformAcceptMimesMiddleware implements MiddlewareMethods {
-  protected acceptMimes = constant<string[]>("acceptMimes", []);
-
-  public $alterEndpointHandlers(handlers: AlterEndpointHandlersArg, operationRoute: JsonOperationRoute) {
-    const hasAcceptMimes = operationRoute.endpoint.acceptMimes.length || this.acceptMimes.length;
-    return {
-      ...handlers,
-      before: [hasAcceptMimes && PlatformAcceptMimesMiddleware, ...handlers.before].filter(Boolean) as any[]
-    };
-  }
-
-  public use(@Context() ctx: Context): void {
-    const {endpoint, request} = ctx;
-    const mimes = uniq((endpoint?.get("acceptMimes") || []).concat(this.acceptMimes));
-
-    if (mimes.length && !request.accepts(mimes)) {
-      throw new NotAcceptable(mimes.join(", "));
-    }
-  }
-}
-
-injectable(PlatformAcceptMimesMiddleware).type(ProviderType.MIDDLEWARE).priority(-10);

package/src/common/middlewares/PlatformMulterMiddleware.ts

@@ -1,6 +0,0 @@
-import {PlatformMulterMiddleware as M} from "@tsed/platform-multer";
-
-/**
- * @deprecated Since version 8.5. Use PlatformMulterMiddleware from @tsed/platform-multer package
- */
-export const PlatformMulterMiddleware: typeof M = M;

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

@@ -1,145 +0,0 @@
-import {nameOf} from "@tsed/core";
-import {Controller} from "@tsed/di";
-import {Get, Post} from "@tsed/schema";
-
-import {PlatformTest} from "../../testing/PlatformTest.js";
-import {application} from "../fn/application.js";
-import {Platform} from "./Platform.js";
-
-@Controller("/my-route")
-class MyCtrl {
-  @Get("/")
-  get() {}
-}
-
-@Controller("/my-sub-route")
-class MySubCtrl {
-  @Get("/")
-  get() {}
-}
-
-@Controller({
-  path: "/my-route",
-  children: [MySubCtrl]
-})
-class MyNestedCtrl {
-  @Get("/")
-  get() {}
-}
-
-@Controller("/")
-export class FlaggedCommentController {
-  @Get("/flag")
-  async list() {}
-
-  @Post("/:commentID/flag")
-  async create() {}
-}
-
-@Controller({
-  path: "/comments",
-  children: [FlaggedCommentController]
-})
-export class CommentController {
-  @Get("/all")
-  get() {}
-}
-
-@Controller({
-  path: "/domain/:contextID",
-  children: [CommentController]
-})
-export class DomainController {
-  @Get("/all")
-  get() {}
-}
-
-@Controller({
-  path: "/platform/:platform",
-  children: [CommentController]
-})
-export class PlatformController {
-  @Get("/")
-  get() {}
-}
-
-describe("Platform", () => {
-  beforeEach(PlatformTest.create);
-  afterEach(PlatformTest.reset);
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  describe("addRoute", () => {
-    it("should add a route", async () => {
-      // GIVEN
-      const platform = await PlatformTest.get<Platform>(Platform);
-
-      vi.spyOn(application(), "use");
-
-      // WHEN
-      platform.addRoutes([{route: "/test", token: MyCtrl}]);
-    });
-    it("should add nested controllers (1)", async () => {
-      // GIVEN
-      const platform = await PlatformTest.get<Platform>(Platform);
-
-      vi.spyOn(application(), "use");
-
-      // WHEN
-      platform.addRoutes([{route: "/rest", token: MyNestedCtrl}]);
-      platform.addRoutes([{route: "/rest", token: MySubCtrl}]);
-
-      platform.getLayers();
-      const result = platform.getMountedControllers();
-
-      // THEN
-      expect(result.length).toEqual(2);
-      expect(result[0].route).toEqual("/rest");
-      expect(result[1].route).toEqual("/rest/my-route");
-    });
-    it("should add nested controllers (2)", async () => {
-      // GIVEN
-      const platform = await PlatformTest.get<Platform>(Platform);
-
-      vi.spyOn(application(), "use");
-
-      // WHEN
-      platform.addRoutes([{route: "/rest", token: DomainController}]);
-      platform.addRoutes([{route: "/rest", token: PlatformController}]);
-
-      platform.getLayers();
-
-      const result = platform.getMountedControllers();
-
-      // THEN
-      const data = result.map((c) => ({route: c.route, name: nameOf(c.provider)}));
-      expect(data).toEqual([
-        {
-          name: "Token:DomainController:DomainController",
-          route: "/rest"
-        },
-        {
-          name: "Token:CommentController:CommentController",
-          route: "/rest/domain/:contextID"
-        },
-        {
-          name: "Token:FlaggedCommentController:FlaggedCommentController",
-          route: "/rest/domain/:contextID/comments"
-        },
-        {
-          name: "Token:PlatformController:PlatformController",
-          route: "/rest"
-        },
-        {
-          name: "Token:CommentController:CommentController",
-          route: "/rest/platform/:platform"
-        },
-        {
-          name: "Token:FlaggedCommentController:FlaggedCommentController",
-          route: "/rest/platform/:platform/comments"
-        }
-      ]);
-    });
-  });
-});

package/src/common/services/Platform.ts

@@ -1,79 +0,0 @@
-import {ControllerProvider, inject, injectable, injector, ProviderScope, TokenProvider} from "@tsed/di";
-import {PlatformLayer, PlatformRouters} from "@tsed/platform-router";
-
-import {application} from "../fn/application.js";
-import {Route, RouteController} from "../interfaces/Route.js";
-
-/**
- * `Platform` is used to provide all routes collected by annotation `@Controller`.
- *
- * @platform
- */
-export class Platform {
-  readonly platformRouters = inject(PlatformRouters);
-  #layers: PlatformLayer[];
-
-  constructor() {
-    this.platformRouters.prebuild();
-  }
-
-  get app() {
-    return application();
-  }
-
-  public addRoutes(routes: Route[]) {
-    routes.forEach((routeSettings) => {
-      this.addRoute(routeSettings.route, routeSettings.token);
-    });
-  }
-
-  public addRoute(route: string, token: TokenProvider) {
-    const app = application();
-    const provider = injector().getProvider(token) as ControllerProvider;
-
-    if (!provider || provider.hasParent()) {
-      return this;
-    }
-
-    const router = this.platformRouters.from(provider.token);
-
-    app.use(route, router);
-
-    return this;
-  }
-
-  public getLayers() {
-    this.#layers = this.#layers || this.platformRouters.getLayers(application());
-
-    return this.#layers;
-  }
-
-  /**
-   * Get all controllers mounted on the application.
-   * @returns  {RouteController[]}
-   */
-  public getMountedControllers() {
-    const controllers = this.getLayers().reduce((controllers, layer) => {
-      if (layer.isProvider()) {
-        const route = String(layer.getBasePath());
-        const key = `${layer.provider.toString()}:${route}`;
-
-        if (!controllers.has(key)) {
-          controllers.set(key, {
-            route,
-            routes: new Set(),
-            provider: layer.provider
-          });
-        }
-
-        controllers.get(key)!.routes.add(String(layer.path));
-      }
-
-      return controllers;
-    }, new Map<string, RouteController>());
-
-    return [...controllers.values()];
-  }
-}
-
-injectable(Platform).scope(ProviderScope.SINGLETON);

package/src/common/services/PlatformAdapter.ts

@@ -1,102 +0,0 @@
-import {IncomingMessage, ServerResponse} from "node:http";
-
-import {Type} from "@tsed/core";
-import {configuration, constant, inject, injectable} from "@tsed/di";
-import {$on} from "@tsed/hooks";
-import type {PlatformMulter, PlatformMulterSettings} from "@tsed/platform-multer";
-import {PlatformHandlerMetadata, PlatformLayer} from "@tsed/platform-router";
-
-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 {Platform} from "./Platform.js";
-import {PlatformApplication} from "./PlatformApplication.js";
-import {PlatformHandler} from "./PlatformHandler.js";
-
-export abstract class PlatformAdapter<App = TsED.Application> {
-  abstract readonly NAME: string;
-
-  readonly app = inject<PlatformApplication<App>>(PlatformApplication);
-
-  constructor() {
-    const platformApp = inject(PlatformApplication);
-
-    const {app, callback} = this.createApp();
-    platformApp.rawApp = app as any;
-    platformApp.rawCallback = callback;
-
-    $on("$afterInvoke", PlatformAdapter, () => {
-      configuration().set("PLATFORM_NAME", constant("PLATFORM_NAME") || this.NAME);
-    });
-  }
-
-  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(): Promise<void> | void;
-
-  /**
-   * 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
-   * @deprecated use inject("MULTER_MODULE")?.get(options) instead
-   */
-  multipart(options: PlatformMulterSettings): PlatformMulter {
-    return inject<any>(Symbol.for("MULTER_MODULE"))?.get(options);
-  }
-
-  /**
-   * 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).imports([PlatformApplication, Platform, PlatformHandler]).alias("PlatformAdapter");