@tsed/platform-http 8.6.0 → 8.7.0

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

@@ -1,95 +0,0 @@
-import {catchAsyncError} from "@tsed/core";
-import {inject} from "@tsed/di";
-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 {PlatformAdapter} from "../services/PlatformAdapter.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 middleware = inject(PlatformMulterMiddleware);
-  const ctx: any = PlatformTest.createRequestContext();
-  ctx.endpoint = EndpointMetadata.get(Test, "upload");
-
-  const adapter = inject(PlatformAdapter);
-
-  vi.spyOn(adapter, "multipart").mockReturnValue(multer as any);
-
-  return {middleware, ctx, multer, adapter, multerMiddleware};
-}
-
-describe("PlatformMulterMiddleware", () => {
-  beforeEach(() =>
-    PlatformTest.create({
-      multer: {
-        dest: "/dest"
-      }
-    })
-  );
-  afterEach(() => PlatformTest.reset());
-  it("should create middleware", async () => {
-    const {middleware, ctx, multer, adapter, multerMiddleware} = await build({});
-
-    await middleware.use(ctx);
-
-    expect(adapter.multipart).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, adapter, multerMiddleware} = await build({
-      storage: "storage"
-    });
-
-    await middleware.use(ctx);
-
-    expect(adapter.multipart).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/services/PlatformMiddlewaresChain.spec.ts

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

@@ -1,53 +0,0 @@
-import {isClass} from "@tsed/core";
-import {constant, 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";
-
-export class PlatformMiddlewaresChain {
-  protected acceptMimes = constant<string[]>("acceptMimes", []);
-
-  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);