@tsed/platform-http 8.0.1 → 8.0.2

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

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

@@ -0,0 +1,24 @@
+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";
+
+/**
+ * @middleware
+ * @platform
+ */
+export class PlatformAcceptMimesMiddleware implements MiddlewareMethods {
+  acceptMimes = constant<string[]>("acceptMimes", []);
+
+  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.spec.ts

@@ -0,0 +1,97 @@
+import {catchAsyncError} from "@tsed/core";
+import {Exception} from "@tsed/exceptions";
+import {MulterError} from "multer";
+
+import {PlatformTest} from "../../testing/PlatformTest.js";
+import {MulterOptions} from "../decorators/multer/multerOptions.js";
+import {MultipartFile} from "../decorators/multer/multipartFile.js";
+import {EndpointMetadata} from "../domain/EndpointMetadata.js";
+import {PlatformApplication} from "../services/PlatformApplication.js";
+import {PlatformMulterMiddleware} from "./PlatformMulterMiddleware.js";
+
+async function build(options = {}) {
+  class Test {
+    @MulterOptions(options)
+    upload(@MultipartFile("file1") file1: any) {}
+  }
+
+  const multerMiddleware = vi.fn();
+  const multer = {
+    fields: vi.fn().mockReturnValue(multerMiddleware)
+  };
+  const app = {
+    multer: vi.fn().mockReturnValue(multer)
+  };
+
+  const middleware = await PlatformTest.invoke<PlatformMulterMiddleware>(PlatformMulterMiddleware, [
+    {
+      token: PlatformApplication,
+      use: app
+    }
+  ]);
+  const ctx: any = PlatformTest.createRequestContext();
+  ctx.endpoint = EndpointMetadata.get(Test, "upload");
+
+  return {middleware, ctx, multer, app, multerMiddleware};
+}
+
+describe("PlatformMulterMiddleware", () => {
+  beforeEach(() =>
+    PlatformTest.create({
+      multer: {
+        dest: "/dest"
+      }
+    })
+  );
+  afterEach(() => PlatformTest.reset());
+  it("should create middleware", async () => {
+    const {middleware, ctx, multer, app, multerMiddleware} = await build({});
+
+    await middleware.use(ctx);
+
+    expect(app.multer).toHaveBeenCalledWith({
+      dest: "/dest"
+    });
+    expect(multer.fields).toHaveBeenCalledWith([{maxCount: undefined, name: "file1"}]);
+    expect(multerMiddleware).toHaveBeenCalledWith(ctx.request.raw, ctx.response.raw);
+  });
+  it("should create middleware with storage", async () => {
+    const {middleware, ctx, multer, app, multerMiddleware} = await build({
+      storage: "storage"
+    });
+
+    await middleware.use(ctx);
+
+    expect(app.multer).toHaveBeenCalledWith({
+      storage: "storage"
+    });
+    expect(multer.fields).toHaveBeenCalledWith([{maxCount: undefined, name: "file1"}]);
+    expect(multerMiddleware).toHaveBeenCalledWith(ctx.request.raw, ctx.response.raw);
+  });
+  it("should catch error with code", async () => {
+    const {middleware, ctx, multerMiddleware} = await build();
+    const error = new MulterError("LIMIT_FILE_SIZE", "field");
+
+    multerMiddleware.mockRejectedValue(error);
+
+    const actualError: any | undefined = await catchAsyncError(() => middleware.use(ctx));
+
+    expect(actualError).toBeInstanceOf(Exception);
+    expect(actualError?.message).toEqual("File too large");
+    expect(actualError?.status).toEqual(400);
+  });
+  it("should throw error without code", async () => {
+    const {middleware, ctx, multerMiddleware} = await build();
+
+    multerMiddleware.mockRejectedValue(new Error("test"));
+
+    let actualError: any;
+    try {
+      await middleware.use(ctx);
+    } catch (er) {
+      actualError = er;
+    }
+
+    expect(actualError.message).toEqual("test");
+  });
+});

package/src/common/middlewares/PlatformMulterMiddleware.ts

@@ -0,0 +1,59 @@
+import {constant, inject, injectable, ProviderType} from "@tsed/di";
+import {BadRequest} from "@tsed/exceptions";
+import {MiddlewareMethods} from "@tsed/platform-middlewares";
+import {Context} from "@tsed/platform-params";
+import type {MulterError} from "multer";
+
+import {PlatformMulterField, PlatformMulterSettings} from "../config/interfaces/PlatformMulterSettings.js";
+import {PlatformContext} from "../domain/PlatformContext.js";
+import {PlatformApplication} from "../services/PlatformApplication.js";
+
+export interface MulterInputOptions {
+  fields: PlatformMulterField[];
+}
+
+export class MulterException extends BadRequest {
+  constructor(er: MulterError) {
+    super(er.message);
+    this.origin = er;
+    this.name = er.code;
+  }
+}
+
+/**
+ * @middleware
+ */
+export class PlatformMulterMiddleware implements MiddlewareMethods {
+  protected app = inject(PlatformApplication);
+
+  async use(@Context() ctx: PlatformContext) {
+    try {
+      const {fields, options = {}} = ctx.endpoint.get(PlatformMulterMiddleware);
+      const settings: PlatformMulterSettings = {
+        ...constant("multer", {}),
+        ...options
+      };
+
+      /* istanbul ignore next */
+      if (settings.storage) {
+        delete settings.dest;
+      }
+
+      const middleware: any = this.app.multer(settings).fields(this.getFields({fields}));
+
+      return await middleware(ctx.getRequest(), ctx.getResponse());
+    } catch (er) {
+      if (er.code) {
+        throw new MulterException(er);
+      }
+
+      throw er;
+    }
+  }
+
+  protected getFields(conf: MulterInputOptions) {
+    return conf.fields.map(({name, maxCount}) => ({name, maxCount}));
+  }
+}
+
+injectable(PlatformMulterMiddleware).type(ProviderType.MIDDLEWARE).priority(-10);

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

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

@@ -0,0 +1,79 @@
+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);