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

package/src/decorators/bodyParams.spec.ts

@@ -1,432 +0,0 @@
-import {Controller} from "@tsed/di";
-import {Description, getJsonSchema, getSpec, JsonParameterStore, MaxLength, MinItems, Post, Required, SpecTypes} from "@tsed/schema";
-
-import {ParamTypes} from "../domain/ParamTypes.js";
-import {BodyParams, RawBodyParams} from "./bodyParams.js";
-
-describe("@BodyParams", () => {
-  it("should call useParam method with the correct parameters", () => {
-    class Test {}
-
-    class Ctrl {
-      test(@BodyParams("expression", Test) body: Test) {}
-    }
-
-    const param = JsonParameterStore.get(Ctrl, "test", 0);
-    expect(param.expression).toEqual("expression");
-    expect(param.paramType).toEqual(ParamTypes.BODY);
-    expect(param.type).toEqual(Test);
-  });
-  it("should create params with Buffer type", () => {
-    @Controller("/")
-    class MyCtrl {
-      @Post()
-      test(@BodyParams() body: Buffer) {}
-    }
-
-    const spec = getSpec(MyCtrl, {specType: SpecTypes.OPENAPI});
-
-    expect(spec).toEqual({
-      paths: {
-        "/": {
-          post: {
-            operationId: "myCtrlTest",
-            parameters: [],
-            requestBody: {
-              content: {
-                "*/*": {
-                  schema: {
-                    type: "string"
-                  }
-                }
-              },
-              required: false
-            },
-            responses: {
-              "200": {
-                description: "Success"
-              }
-            },
-            tags: ["MyCtrl"]
-          }
-        }
-      },
-      tags: [
-        {
-          name: "MyCtrl"
-        }
-      ]
-    });
-  });
-  it("should generate the correct spec for BodyParams from metadata (string)", () => {
-    class TestModel {
-      @Required()
-      name: string;
-    }
-
-    @Controller("/")
-    class MyCtrl {
-      @Post()
-      test(@BodyParams() @Required() @MaxLength(10) @Description("Description") body: string) {}
-    }
-
-    const spec = getSpec(MyCtrl, {specType: SpecTypes.OPENAPI});
-
-    expect(spec).toEqual({
-      paths: {
-        "/": {
-          post: {
-            operationId: "myCtrlTest",
-            parameters: [],
-            requestBody: {
-              description: "Description",
-              content: {
-                "application/json": {
-                  schema: {
-                    minLength: 1,
-                    maxLength: 10,
-                    type: "string"
-                  }
-                }
-              },
-              required: true
-            },
-            responses: {
-              "200": {
-                description: "Success"
-              }
-            },
-            tags: ["MyCtrl"]
-          }
-        }
-      },
-      tags: [
-        {
-          name: "MyCtrl"
-        }
-      ]
-    });
-  });
-  it("should generate the correct spec for BodyParams from metadata (string[])", () => {
-    class TestModel {
-      @Required()
-      name: string;
-    }
-
-    @Controller("/")
-    class MyCtrl {
-      @Post()
-      test(@BodyParams(String) @Required() @MaxLength(10) @MinItems(3) @Description("Description") body: string[]) {}
-    }
-
-    const spec = getSpec(MyCtrl, {specType: SpecTypes.OPENAPI});
-
-    expect(spec).toEqual({
-      paths: {
-        "/": {
-          post: {
-            operationId: "myCtrlTest",
-            parameters: [],
-            requestBody: {
-              description: "Description",
-              content: {
-                "application/json": {
-                  schema: {
-                    items: {
-                      maxLength: 10,
-                      type: "string"
-                    },
-                    minItems: 3,
-                    type: "array"
-                  }
-                }
-              },
-              required: true
-            },
-            responses: {
-              "200": {
-                description: "Success"
-              }
-            },
-            tags: ["MyCtrl"]
-          }
-        }
-      },
-      tags: [
-        {
-          name: "MyCtrl"
-        }
-      ]
-    });
-  });
-  it("should generate the correct spec for BodyParams from metadata (TestModel)", () => {
-    class TestModel {
-      @Required()
-      name: string;
-    }
-
-    @Controller("/")
-    class MyCtrl {
-      @Post()
-      test(@BodyParams() @Required() @Description("Description") body: TestModel) {}
-    }
-
-    const spec = getSpec(MyCtrl, {specType: SpecTypes.OPENAPI});
-
-    expect(spec).toEqual({
-      components: {
-        schemas: {
-          TestModel: {
-            properties: {
-              name: {
-                minLength: 1,
-                type: "string"
-              }
-            },
-            required: ["name"],
-            type: "object"
-          }
-        }
-      },
-      paths: {
-        "/": {
-          post: {
-            operationId: "myCtrlTest",
-            parameters: [],
-            requestBody: {
-              description: "Description",
-              content: {
-                "application/json": {
-                  schema: {$ref: "#/components/schemas/TestModel"}
-                }
-              },
-              required: true
-            },
-            responses: {
-              "200": {
-                description: "Success"
-              }
-            },
-            tags: ["MyCtrl"]
-          }
-        }
-      },
-      tags: [
-        {
-          name: "MyCtrl"
-        }
-      ]
-    });
-    const param = JsonParameterStore.get(MyCtrl, "test", 0);
-    const schema = getJsonSchema(param);
-
-    expect(schema).toEqual({
-      properties: {
-        name: {
-          minLength: 1,
-          type: "string"
-        }
-      },
-      required: ["name"],
-      type: "object"
-    });
-  });
-  it("should generate the correct spec for BodyParams from metadata (TestModel[])", () => {
-    class TestModel {
-      @Required()
-      name: string;
-    }
-
-    @Controller("/")
-    class MyCtrl {
-      @Post()
-      test(@BodyParams(TestModel) @MinItems(2) @Required() @Description("Description") body: TestModel[]) {}
-    }
-
-    const spec = getSpec(MyCtrl, {specType: SpecTypes.OPENAPI});
-
-    expect(spec).toEqual({
-      components: {
-        schemas: {
-          TestModel: {
-            properties: {
-              name: {
-                minLength: 1,
-                type: "string"
-              }
-            },
-            required: ["name"],
-            type: "object"
-          }
-        }
-      },
-      paths: {
-        "/": {
-          post: {
-            operationId: "myCtrlTest",
-            parameters: [],
-            requestBody: {
-              content: {
-                "application/json": {
-                  schema: {
-                    items: {
-                      $ref: "#/components/schemas/TestModel"
-                    },
-                    minItems: 2,
-                    type: "array"
-                  }
-                }
-              },
-              description: "Description",
-              required: true
-            },
-            responses: {
-              "200": {
-                description: "Success"
-              }
-            },
-            tags: ["MyCtrl"]
-          }
-        }
-      },
-      tags: [
-        {
-          name: "MyCtrl"
-        }
-      ]
-    });
-  });
-  it("should generate the correct spec for BodyParams from given type (TestModel)", () => {
-    class TestModel {
-      @Required()
-      name: string;
-    }
-
-    @Controller("/")
-    class MyCtrl {
-      @Post()
-      test(@BodyParams(TestModel) @Required() @Description("Description") body: any) {}
-    }
-
-    const spec = getSpec(MyCtrl, {specType: SpecTypes.OPENAPI});
-
-    expect(spec).toEqual({
-      components: {
-        schemas: {
-          TestModel: {
-            properties: {
-              name: {
-                minLength: 1,
-                type: "string"
-              }
-            },
-            required: ["name"],
-            type: "object"
-          }
-        }
-      },
-      paths: {
-        "/": {
-          post: {
-            operationId: "myCtrlTest",
-            parameters: [],
-            requestBody: {
-              description: "Description",
-              content: {
-                "application/json": {
-                  schema: {$ref: "#/components/schemas/TestModel"}
-                }
-              },
-              required: true
-            },
-            responses: {
-              "200": {
-                description: "Success"
-              }
-            },
-            tags: ["MyCtrl"]
-          }
-        }
-      },
-      tags: [
-        {
-          name: "MyCtrl"
-        }
-      ]
-    });
-
-    const param = JsonParameterStore.get(MyCtrl, "test", 0);
-    const schema = getJsonSchema(param);
-
-    expect(schema).toEqual({
-      properties: {
-        name: {
-          minLength: 1,
-          type: "string"
-        }
-      },
-      required: ["name"],
-      type: "object"
-    });
-  });
-});
-
-describe("RawBodyParams()", () => {
-  it("should declare a RawBodyParams", () => {
-    @Controller("/")
-    class MyCtrl {
-      @Post()
-      test(@RawBodyParams() body: Buffer) {}
-    }
-
-    const spec = getSpec(MyCtrl, {specType: SpecTypes.OPENAPI});
-
-    expect(spec).toEqual({
-      paths: {
-        "/": {
-          post: {
-            operationId: "myCtrlTest",
-            parameters: [],
-            requestBody: {
-              content: {
-                "*/*": {
-                  schema: {
-                    type: "string"
-                  }
-                }
-              },
-              required: false
-            },
-            responses: {
-              "200": {
-                description: "Success"
-              }
-            },
-            tags: ["MyCtrl"]
-          }
-        }
-      },
-      tags: [
-        {
-          name: "MyCtrl"
-        }
-      ]
-    });
-
-    const param = JsonParameterStore.get(MyCtrl, "test", 0);
-    expect(param.paramType).toEqual(ParamTypes.RAW_BODY);
-    expect(param.type).toEqual(Buffer);
-    expect(param.pipes).toHaveLength(0);
-  });
-  it("should declare RawBodyParams with options", () => {
-    class Ctrl {
-      test(@RawBodyParams({useValidation: true, useType: String}) param: Date) {}
-    }
-
-    const param = JsonParameterStore.get(Ctrl, "test", 0);
-    expect(param.expression).toEqual(undefined);
-    expect(param.paramType).toEqual(ParamTypes.RAW_BODY);
-    expect(param.type).toEqual(String);
-    expect(param.pipes).toHaveLength(1);
-  });
-});

package/src/decorators/bodyParams.ts

@@ -1,93 +0,0 @@
-import {Type} from "@tsed/core";
-
-import {ParamOptions} from "../domain/ParamOptions.js";
-import {ParamTypes} from "../domain/ParamTypes.js";
-import {mapParamsOptions} from "../utils/mapParamsOptions.js";
-import {UseParam} from "./useParam.js";
-
-/**
- * BodyParams return the value from [request.body](http://expressjs.com/en/4x/api.html#req.body) object.
- *
- * #### Example
- *
- * ```typescript
- * @Controller('/')
- * class MyCtrl {
- *    @Post('/')
- *    create(@BodyParams() body: any) {
- *       console.log('Entire body', body);
- *    }
- *
- *    @Post('/')
- *    create(@BodyParams('id') id: string) {
- *       console.log('ID', id);
- *    }
- *
- *    @Post('/')
- *    create(@BodyParams('user') user: User) { // with deserialization
- *       console.log('user', user);
- *    }
- *
- *    @Post('/')
- *    create(@BodyParams('users', User) users: User[]) { // with deserialization
- *       console.log('users', users);
- *    }
- * }
- * ```
- * > For more information on deserialization see [converters](/docs/json-mapper.md) page.
- *
- * @param expression The path of the property to get.
- * @param useType The type of the class that to be used to deserialize the data.
- * @decorator
- * @operation
- * @input
- */
-export function BodyParams(expression: string, useType: Type<any>): ParameterDecorator;
-export function BodyParams(expression: string): ParameterDecorator;
-export function BodyParams(useType: Type<any>): ParameterDecorator;
-export function BodyParams(options: Partial<ParamOptions>): ParameterDecorator;
-export function BodyParams(): ParameterDecorator;
-export function BodyParams(...args: any[]): ParameterDecorator {
-  const {expression, useType, useMapper = true, useValidation = true} = mapParamsOptions(args);
-
-  return UseParam({
-    paramType: ParamTypes.BODY,
-    expression,
-    useType,
-    useMapper,
-    useValidation
-  });
-}
-
-/**
- * RawBodyParams return the value from [request.body](http://expressjs.com/en/4x/api.html#req.body) as a Buffer.
- *
- * #### Example
- *
- * ```typescript
- * @Controller('/')
- * class MyCtrl {
- *    @Post('/')
- *    create(@RawBodyParams() body: Buffer) {
- *       console.log('Entire body', body.toString("utf8"));
- *    }
- * }
- * ```
- *
- * @decorator
- * @operation
- * @input
- * @alias BodyParams Example: @BodyParams() payload: Buffer
- */
-export function RawBodyParams(options: Partial<Omit<ParamOptions, "expression">>): ParameterDecorator;
-export function RawBodyParams(): ParameterDecorator;
-export function RawBodyParams(...args: any[]): ParameterDecorator {
-  const {useType, useMapper = false, useValidation = false} = mapParamsOptions(args);
-
-  return UseParam({
-    paramType: ParamTypes.RAW_BODY,
-    useType,
-    useMapper,
-    useValidation
-  });
-}

package/src/decorators/context.spec.ts

@@ -1,16 +0,0 @@
-import {JsonParameterStore} from "@tsed/schema";
-
-import {ParamTypes} from "../domain/ParamTypes.js";
-import {Context} from "./context.js";
-
-describe("@Context", () => {
-  it("should call ParamFilter.useParam method with the correct parameters", () => {
-    class Ctrl {
-      test(@Context("expression") test: any) {}
-    }
-
-    const param = JsonParameterStore.get(Ctrl, "test", 0);
-    expect(param.expression).toEqual("expression");
-    expect(param.paramType).toEqual(ParamTypes.$CTX);
-  });
-});

package/src/decorators/context.ts

@@ -1,70 +0,0 @@
-import {BaseContext} from "@tsed/di";
-
-import {ParamTypes} from "../domain/ParamTypes.js";
-import {mapParamsOptions} from "../utils/mapParamsOptions.js";
-import {UseParam} from "./useParam.js";
-
-/**
- * Context decorator return the @@PlatformContext@@ created by Ts.ED when request is handled by the server.
- *
- * It contains some information as following:
- *
- * - The request id,
- * - The request container used by the Ts.ED DI. It contain all services annotated with `@Scope(ProviderScope.REQUEST)`,
- * - The current @@EndpointMetadata@@ resolved by Ts.ED during the request,
- * - The data return by the previous endpoint if you use multiple handler on the same route. By default data is empty.
- *
- * ::: tip
- * The @@PlatformContext@@ inherit from Map class. So you can store any information with.
- * :::
- *
- * #### Example
- *
- * ```typescript
- * @Middleware()
- * class AuthTokenMiddleware {
- *   use(@Req() request: Req, @Context() context: PlatformContext) {
- *      if (!context.has("auth")){
- *        context.set('auth', new AuthToken(request))
- *      }
- *
- *      try {
- *        context.get("auth").claims() // check token
- *      } catch(er){
- *        throw new Forbidden("Access forbidden - Bad token")
- *      }
- *   }
- * }
- *
- * @Controller('/')
- * @UseBefore(AuthTokenMiddleware) // protect all routes for this controller
- * class MyCtrl {
- *    @Get('/')
- *    get(@Context('auth') auth: AuthToken) {
- *       console.log('auth', auth);
- *       console.log('auth.accessToken', auth.accessToken);
- *       console.log('auth.idToken', auth.idToken);
- *    }
- * }
- * ```
- *
- * @param expression The path of the property to get.
- * @decorator
- * @operation
- * @input
- */
-export function Context(expression: string): ParameterDecorator;
-export function Context(): ParameterDecorator;
-export function Context(...args: any[]): ParameterDecorator {
-  const {expression, useType, useMapper = false, useValidation = false} = mapParamsOptions(args);
-
-  return UseParam({
-    paramType: ParamTypes.$CTX,
-    expression,
-    useType,
-    useMapper,
-    useValidation
-  });
-}
-
-export type Context = BaseContext;

package/src/decorators/cookies.spec.ts

@@ -1,19 +0,0 @@
-import {JsonParameterStore} from "@tsed/schema";
-
-import {ParamTypes} from "../domain/ParamTypes.js";
-import {Cookies} from "./cookies.js";
-
-describe("@Cookies", () => {
-  it("should call ParamFilter.useParam method with the correct parameters", () => {
-    class Test {}
-
-    class Ctrl {
-      test(@Cookies("expression", Test) body: Test) {}
-    }
-
-    const param = JsonParameterStore.get(Ctrl, "test", 0);
-    expect(param.expression).toEqual("expression");
-    expect(param.paramType).toEqual(ParamTypes.COOKIES);
-    expect(param.type).toEqual(Test);
-  });
-});