@tsed/platform-http 8.0.1 → 8.0.2

package/src/common/decorators/multer/multipartFile.spec.ts

@@ -0,0 +1,259 @@
+import "../../index.js";
+
+import {descriptorOf, Metadata, Store} from "@tsed/core";
+import {ParamTypes} from "@tsed/platform-params";
+import {getSpec, JsonParameterStore, Post, SpecTypes} from "@tsed/schema";
+
+import {PlatformMulterMiddleware} from "../../middlewares/PlatformMulterMiddleware.js";
+import {MultipartFile} from "./multipartFile.js";
+
+class Test {
+  test() {}
+}
+
+describe("@MultipartFile()", () => {
+  describe("one file", () => {
+    // WHEN
+    class TestController {
+      @Post("/")
+      test(@MultipartFile("file1", 1) file: any) {}
+    }
+
+    // THEN
+    const store = Store.fromMethod(TestController, "test");
+    const param = JsonParameterStore.get(TestController, "test", 0);
+
+    it("should set params properly", () => {
+      expect(store.get(PlatformMulterMiddleware)).toEqual({
+        fields: [
+          {
+            maxCount: 1,
+            name: "file1"
+          }
+        ]
+      });
+      expect(param.expression).toEqual("file1.0");
+      expect(param.paramType).toEqual(ParamTypes.FILES);
+    });
+
+    it("should set endpoint metadata - OS3", () => {
+      expect(getSpec(TestController, {specType: SpecTypes.OPENAPI})).toEqual({
+        paths: {
+          "/": {
+            post: {
+              operationId: "testControllerTest",
+              parameters: [],
+              responses: {
+                "400": {
+                  content: {"application/json": {schema: {$ref: "#/components/schemas/BadRequest"}}},
+                  description:
+                    "<File too long | Too many parts | Too many files | Field name too long | Field value too long | Too many fields | Unexpected field>  [fieldName] Example: File too long file1"
+                }
+              },
+              requestBody: {
+                required: false,
+                content: {
+                  "multipart/form-data": {
+                    schema: {
+                      properties: {file1: {type: "string", format: "binary"}},
+                      type: "object"
+                    }
+                  }
+                }
+              },
+              tags: ["TestController"]
+            }
+          }
+        },
+        tags: [{name: "TestController"}],
+        components: {
+          schemas: {
+            GenericError: {
+              additionalProperties: true,
+              properties: {
+                message: {
+                  description: "An error message",
+                  minLength: 1,
+                  type: "string"
+                },
+                name: {
+                  description: "The error name",
+                  minLength: 1,
+                  type: "string"
+                }
+              },
+              required: ["name", "message"],
+              type: "object"
+            },
+            BadRequest: {
+              type: "object",
+              properties: {
+                name: {
+                  type: "string",
+                  minLength: 1,
+                  description: "The error name",
+                  example: "BAD_REQUEST",
+                  default: "BAD_REQUEST"
+                },
+                message: {type: "string", minLength: 1, description: "An error message"},
+                status: {type: "number", description: "The status code of the exception", example: 400, default: 400},
+                errors: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/GenericError"
+                  },
+                  description: "A list of related errors"
+                },
+                stack: {
+                  type: "string",
+                  description: "The stack trace (only in development mode)"
+                }
+              },
+              required: ["name", "message", "status"]
+            }
+          }
+        }
+      });
+    });
+  });
+
+  describe("multiple file schema", () => {
+    // WHEN
+    class TestController {
+      @Post("/")
+      test(@MultipartFile("file1", 4) file: any[]) {}
+    }
+
+    // THEN
+    const store = Store.fromMethod(TestController, "test");
+    const param = JsonParameterStore.get(TestController, "test", 0);
+
+    it("should set params properly", () => {
+      expect(store.get(PlatformMulterMiddleware)).toEqual({
+        fields: [
+          {
+            maxCount: 4,
+            name: "file1"
+          }
+        ]
+      });
+      expect(param.expression).toEqual("file1");
+      expect(param.paramType).toEqual(ParamTypes.FILES);
+    });
+
+    it("should set endpoint metadata - OS3", () => {
+      expect(getSpec(TestController, {specType: SpecTypes.OPENAPI})).toEqual({
+        paths: {
+          "/": {
+            post: {
+              operationId: "testControllerTest",
+              parameters: [],
+              responses: {
+                "400": {
+                  content: {"application/json": {schema: {$ref: "#/components/schemas/BadRequest"}}},
+                  description:
+                    "<File too long | Too many parts | Too many files | Field name too long | Field value too long | Too many fields | Unexpected field>  [fieldName] Example: File too long file1"
+                }
+              },
+              requestBody: {
+                required: false,
+                content: {
+                  "multipart/form-data": {
+                    schema: {
+                      properties: {file1: {type: "array", items: {type: "string", format: "binary"}}},
+                      type: "object"
+                    }
+                  }
+                }
+              },
+              tags: ["TestController"]
+            }
+          }
+        },
+        tags: [{name: "TestController"}],
+        components: {
+          schemas: {
+            GenericError: {
+              additionalProperties: true,
+              properties: {
+                message: {
+                  description: "An error message",
+                  minLength: 1,
+                  type: "string"
+                },
+                name: {
+                  description: "The error name",
+                  minLength: 1,
+                  type: "string"
+                }
+              },
+              required: ["name", "message"],
+              type: "object"
+            },
+            BadRequest: {
+              type: "object",
+              properties: {
+                name: {
+                  type: "string",
+                  minLength: 1,
+                  description: "The error name",
+                  example: "BAD_REQUEST",
+                  default: "BAD_REQUEST"
+                },
+                message: {
+                  type: "string",
+                  minLength: 1,
+                  description: "An error message"
+                },
+                status: {type: "number", description: "The status code of the exception", example: 400, default: 400},
+                errors: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/GenericError"
+                  },
+                  description: "A list of related errors"
+                },
+                stack: {
+                  type: "string",
+                  description: "The stack trace (only in development mode)"
+                }
+              },
+              required: ["name", "message", "status"]
+            }
+          }
+        }
+      });
+    });
+  });
+
+  describe("multiple files", () => {
+    afterAll(() => {
+      vi.clearAllMocks();
+    });
+
+    it("should set params metadata", () => {
+      const store = Store.from(Test.prototype, "test", descriptorOf(Test.prototype, "test"));
+      store.delete("multipartAdded");
+
+      // @ts-ignore
+      store.delete(PlatformMulterMiddleware);
+      vi.spyOn(Store, "fromMethod").mockReturnValue(store);
+      vi.spyOn(Metadata, "getParamTypes").mockReturnValue([Array]);
+
+      MultipartFile("file1", 8)(Test.prototype, "test", 0);
+
+      expect(store.get(PlatformMulterMiddleware)).toEqual({
+        fields: [
+          {
+            maxCount: 8,
+            name: "file1"
+          }
+        ]
+      });
+
+      const param = JsonParameterStore.get(Test, "test", 0);
+      expect(param.expression).toEqual("file1");
+      expect(param.paramType).toEqual(ParamTypes.FILES);
+    });
+  });
+});

package/src/common/decorators/multer/multipartFile.ts

@@ -0,0 +1,88 @@
+import {DecoratorParameters, Metadata, StoreMerge, useDecorators, useMethodDecorators} from "@tsed/core";
+import {ParamTypes, UseParam} from "@tsed/platform-params";
+import {InFile} from "@tsed/schema";
+
+import {PlatformMulterFile} from "../../config/interfaces/PlatformMulterSettings.js";
+import {MulterInputOptions, PlatformMulterMiddleware} from "../../middlewares/PlatformMulterMiddleware.js";
+
+function mapOptions(name: string, maxCount: number | undefined): MulterInputOptions {
+  return {
+    fields: [
+      {
+        name,
+        maxCount
+      }
+    ]
+  };
+}
+
+/**
+ * Define a parameter as Multipart file.
+ *
+ * ```typescript
+ * import {Post} from "@tsed/schema";
+ * import {Controller, MulterOptions, MultipartFile} from "@tsed/platform-http";
+ * import {Controller} from "@tsed/di";
+ * import {Multer} from "@types/multer";
+ *
+ * type MulterFile = Express.Multer.File;
+ *
+ * @Controller('/')
+ * class MyCtrl {
+ *   @Post('/file')
+ *   private uploadFile(@MultipartFile("file1") file: MulterFile) {
+ *
+ *   }
+ *
+ *   @Post('/file')
+ *   @MulterOptions({dest: "/other-dir"})
+ *   private uploadFile(@MultipartFile("file1") file: MulterFile) {
+ *
+ *   }
+ *
+ *   @Post('/file2')
+ *   @MulterOptions({dest: "/other-dir"})
+ *   private uploadFile(@MultipartFile("file1") file: MulterFile, @MultipartFile("file2") file2: MulterFile) {
+ *
+ *   }
+ *
+ *   @Post('/files')
+ *   private uploadFile(@MultipartFile("file1") files: MulterFile[]) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * > See the tutorial on the [multer configuration](/docs/upload-files.md).
+ *
+ * @param name
+ * @param maxCount
+ * @returns Function
+ * @decorator
+ * @input
+ */
+export function MultipartFile(name: string, maxCount?: number): ParameterDecorator {
+  return (...args: DecoratorParameters): void => {
+    const [target, propertyKey, index] = args;
+    const multiple = Metadata.getParamTypes(target, propertyKey)[index as number] === Array;
+
+    name = (typeof name === "object" ? undefined : name)!;
+
+    const expression = [name, !multiple && "0"].filter(Boolean).join(".");
+
+    const decorators = useDecorators(
+      InFile(name),
+      useMethodDecorators(StoreMerge(PlatformMulterMiddleware, mapOptions(name, maxCount))),
+      UseParam({
+        paramType: ParamTypes.FILES,
+        dataPath: "$ctx.request.files",
+        expression,
+        useValidation: true
+      })
+    );
+
+    decorators(...args);
+  };
+}
+
+export type MultipartFile = PlatformMulterFile;

package/src/common/decorators/params/error.spec.ts

@@ -0,0 +1,15 @@
+import {ParamTypes} from "@tsed/platform-params";
+import {JsonParameterStore} from "@tsed/schema";
+
+import {Err} from "./error.js";
+
+describe("@Err", () => {
+  it("should register a new parameter instance with the correct property", () => {
+    class Ctrl {
+      test(@Err() arg: unknown) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual(ParamTypes.ERR);
+  });
+});

package/src/common/decorators/params/error.ts

@@ -0,0 +1,16 @@
+import {ParamTypes, UseParam} from "@tsed/platform-params";
+
+/**
+ * @returns {Function}
+ * @decorator
+ * @operation
+ * @input
+ */
+export function Err(): Function {
+  return UseParam({
+    paramType: ParamTypes.ERR,
+    dataPath: "$ctx.error",
+    useValidation: false,
+    useMapper: false
+  });
+}

package/src/common/decorators/params/next.spec.ts

@@ -0,0 +1,15 @@
+import {ParamTypes} from "@tsed/platform-params";
+import {JsonParameterStore} from "@tsed/schema";
+
+import {Next} from "./next.js";
+
+describe("@Next", () => {
+  it("should register a new parameter instance with the correct property", () => {
+    class Ctrl {
+      test(@Next() arg: any) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual(ParamTypes.NEXT_FN);
+  });
+});

package/src/common/decorators/params/next.ts

@@ -0,0 +1,31 @@
+import {ParamTypes, UseParam} from "@tsed/platform-params";
+
+/**
+ * Get the Next function (for express application and middleware).
+ *
+ * @decorator
+ * @operation
+ * @input
+ */
+export function Next(): ParameterDecorator {
+  return UseParam({
+    paramType: ParamTypes.NEXT_FN,
+    dataPath: "next",
+    useMapper: false,
+    useValidation: false
+  });
+}
+
+declare global {
+  namespace TsED {
+    export interface NextFunction extends Function {}
+  }
+}
+/**
+ * Get the Next function (for express application and middleware).
+ *
+ * @decorator
+ * @operation
+ * @input
+ */
+export type Next = TsED.NextFunction;

package/src/common/decorators/params/request.spec.ts

@@ -0,0 +1,49 @@
+import {ParamTypes} from "@tsed/platform-params";
+import {JsonParameterStore} from "@tsed/schema";
+import {IncomingMessage} from "http";
+
+import {PlatformRequest} from "../../services/PlatformRequest.js";
+import {Req, Request} from "./request.js";
+
+describe("@Req", () => {
+  it("should register a new parameter instance with the correct property (RawRequest)", () => {
+    class Ctrl {
+      test(@Request() arg: Req) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual(ParamTypes.REQUEST);
+    expect(param.type).toEqual(Req);
+  });
+
+  it("should register a new parameter instance with the correct property (RawRequest with expression)", () => {
+    class Ctrl {
+      test(@Req("user") arg: Req) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual(ParamTypes.REQUEST);
+    expect(param.expression).toEqual("user");
+    expect(param.type).toEqual(Req);
+  });
+
+  it("should register a new parameter instance with the correct property (PlatformRequest)", () => {
+    class Ctrl {
+      test(@Req() arg: PlatformRequest) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual(ParamTypes.PLATFORM_REQUEST);
+    expect(param.type).toEqual(PlatformRequest);
+  });
+
+  it("should register a new parameter instance with the correct property (IncomingMessage)", () => {
+    class Ctrl {
+      test(@Req() arg: IncomingMessage) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual(ParamTypes.NODE_REQUEST);
+    expect(param.type).toEqual(IncomingMessage);
+  });
+});

package/src/common/decorators/params/request.ts

@@ -0,0 +1,85 @@
+import {isClass, Metadata, nameOf, Type} from "@tsed/core";
+import {mapParamsOptions, ParamOptions, ParamTypes, UseParam} from "@tsed/platform-params";
+import {IncomingMessage} from "http";
+
+function getParamType(target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) {
+  const type = Metadata.getOwnParamTypes(target, propertyKey)[parameterIndex];
+
+  if (isClass(type)) {
+    if (nameOf(type) === "PlatformRequest") {
+      return {paramType: ParamTypes.PLATFORM_REQUEST, dataPath: "$ctx.request"};
+    }
+
+    if (type === IncomingMessage) {
+      return {paramType: ParamTypes.NODE_REQUEST, dataPath: "$ctx.request.req"};
+    }
+  }
+
+  return {paramType: ParamTypes.REQUEST, dataPath: "$ctx.request.request"};
+}
+
+/**
+ * Request service.
+ *
+ * @decorator
+ * @operation
+ * @input
+ */
+export function Request(expression: string, useType: Type<any>): ParameterDecorator;
+export function Request(expression: string): ParameterDecorator;
+export function Request(useType: Type<any>): ParameterDecorator;
+export function Request(options: ParamOptions<any>): ParameterDecorator;
+export function Request(): ParameterDecorator;
+export function Request(...args: any[]): ParameterDecorator {
+  // @ts-ignore
+  return Req(...args);
+}
+
+/**
+ * Request service.
+ *
+ * @alias Request
+ * @decorator
+ * @operation
+ * @input
+ */
+export function Req(expression: string, useType: Type<any>): ParameterDecorator;
+export function Req(expression: string): ParameterDecorator;
+export function Req(useType: Type<any>): ParameterDecorator;
+export function Req(options: Partial<ParamOptions>): ParameterDecorator;
+export function Req(): ParameterDecorator;
+export function Req(...args: any[]): ParameterDecorator {
+  const {expression, useType, useMapper = false, useValidation = false} = mapParamsOptions(args);
+
+  return (target, propertyKey, parameterIndex) => {
+    const {paramType, dataPath} = getParamType(target, propertyKey, parameterIndex);
+
+    UseParam({
+      paramType,
+      dataPath,
+      expression,
+      useType,
+      useMapper,
+      useValidation
+    })(target, propertyKey, parameterIndex);
+  };
+}
+
+/**
+ * Request service.
+ *
+ * @decorator
+ * @operation
+ * @input
+ */
+export interface Request extends TsED.Request {}
+
+/**
+ * Request service.
+ *
+ * @alias Request
+ * @decorator
+ * @operation
+ * @input
+ */
+export interface Req extends Request {}

package/src/common/decorators/params/response.spec.ts

@@ -0,0 +1,36 @@
+import {ParamTypes} from "@tsed/platform-params";
+import {JsonParameterStore} from "@tsed/schema";
+import {ServerResponse} from "http";
+
+import {PlatformResponse} from "../../services/PlatformResponse.js";
+import {Res, Response} from "./response.js";
+
+describe("@Res", () => {
+  it("should register a new parameter instance with the correct property (RawRes)", () => {
+    class Ctrl {
+      test(@Response() arg: Response) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual(ParamTypes.RESPONSE);
+    expect(param.type).toEqual(Response);
+  });
+  it("should register a new parameter instance with the correct property (PlatformResponse)", () => {
+    class Ctrl {
+      test(@Response() arg: PlatformResponse) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual(ParamTypes.PLATFORM_RESPONSE);
+    expect(param.type).toEqual(PlatformResponse);
+  });
+  it("should register a new parameter instance with the correct property (ServerResponse)", () => {
+    class Ctrl {
+      test(@Response() arg: ServerResponse) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.paramType).toEqual(ParamTypes.NODE_RESPONSE);
+    expect(param.type).toEqual(ServerResponse);
+  });
+});

package/src/common/decorators/params/response.ts

@@ -0,0 +1,73 @@
+import {isClass, Metadata, nameOf} from "@tsed/core";
+import {ParamTypes, UseParam} from "@tsed/platform-params";
+import {ServerResponse} from "http";
+
+function getParamType(target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) {
+  const type = Metadata.getOwnParamTypes(target, propertyKey)[parameterIndex];
+
+  if (isClass(type)) {
+    if (nameOf(type) === "PlatformResponse") {
+      return {paramType: ParamTypes.PLATFORM_RESPONSE, dataPath: "$ctx.response"};
+    }
+
+    if (type === ServerResponse) {
+      return {paramType: ParamTypes.NODE_RESPONSE, dataPath: "$ctx.response.res"};
+    }
+  }
+
+  return {paramType: ParamTypes.RESPONSE, dataPath: "$ctx.response.response"};
+}
+
+/**
+ * Response service.
+ *
+ * @decorator
+ * @operation
+ * @input
+ * @response
+ */
+export function Response(): ParameterDecorator;
+export function Response(): ParameterDecorator {
+  return Res();
+}
+
+/**
+ * Request service.
+ *
+ * @alias Response
+ * @decorator
+ * @operation
+ * @input
+ * @response
+ */
+export function Res(): ParameterDecorator;
+export function Res(): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    const {paramType, dataPath} = getParamType(target, propertyKey, parameterIndex);
+    UseParam({
+      paramType,
+      dataPath
+    })(target, propertyKey, parameterIndex);
+  };
+}
+
+/**
+ * Response service.
+ *
+ * @decorator
+ * @operation
+ * @input
+ * @response
+ */
+export interface Response extends TsED.Response {}
+
+/**
+ * Response service.
+ *
+ * @alias Response
+ * @decorator
+ * @operation
+ * @input
+ * @response
+ */
+export interface Res extends Response {}

package/src/common/domain/AnyToPromiseWithCtx.spec.ts

@@ -0,0 +1,20 @@
+import {PlatformTest} from "../../testing/PlatformTest.js";
+import {AnyToPromiseWithCtx} from "./AnyToPromiseWithCtx.js";
+
+describe("AnyToPromiseWithCtx", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+
+  it("should return value", async () => {
+    const $ctx = PlatformTest.createRequestContext();
+    const resolver = new AnyToPromiseWithCtx($ctx);
+
+    const result = await resolver.call(() => "hello");
+
+    expect(result).toEqual({
+      data: "hello",
+      state: "RESOLVED",
+      type: "DATA"
+    });
+  });
+});