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

package/src/decorators/useParam.spec.ts

@@ -1,82 +0,0 @@
-import {Description, Example, Get, getSpec, JsonParameterStore, Property, Required, SpecTypes, Title} from "@tsed/schema";
-
-import {ParamTypes} from "../domain/ParamTypes.js";
-import {QueryParams} from "./queryParams.js";
-import {UseParam} from "./useParam.js";
-
-export class MyModel {
-  @Title("iD")
-  @Description("Description of calendar model id")
-  @Example("Description example")
-  @Property()
-  public id: string;
-
-  @Property()
-  @Required()
-  public name: string;
-}
-
-describe("@UseParam", () => {
-  describe("when use a param", () => {
-    it("should create useParam", () => {
-      class Test {}
-
-      class Ctrl {
-        test(
-          @UseParam({
-            expression: "expression",
-            useMapper: true,
-            useValidation: true,
-            paramType: ParamTypes.BODY,
-            useType: 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);
-    });
-  });
-  describe("when is a Query param with boolean", () => {
-    it("should return the right spec", () => {
-      class Ctrl {
-        @Get("/")
-        get(@QueryParams("test") value: boolean) {}
-      }
-
-      const spec = getSpec(Ctrl, {specType: SpecTypes.OPENAPI});
-
-      expect(spec).toEqual({
-        paths: {
-          "/": {
-            get: {
-              operationId: "ctrlGet",
-              parameters: [
-                {
-                  in: "query",
-                  name: "test",
-                  required: false,
-                  schema: {type: "boolean"}
-                }
-              ],
-              responses: {
-                "200": {
-                  description: "Success"
-                }
-              },
-              tags: ["Ctrl"]
-            }
-          }
-        },
-        tags: [
-          {
-            name: "Ctrl"
-          }
-        ]
-      });
-    });
-  });
-});

package/src/decorators/useParam.ts

@@ -1,38 +0,0 @@
-import {useDecorators} from "@tsed/core";
-
-import {ParamOptions} from "../domain/ParamOptions.js";
-import {ParamTypes} from "../domain/ParamTypes.js";
-import {UseDeserialization} from "./useDeserialization.js";
-import {UseParamType} from "./useParamType.js";
-import {UseType} from "./useType.js";
-import {UseValidation} from "./useValidation.js";
-
-/**
- * @ignore
- * @param options
- */
-function mapPipes(options: Partial<ParamOptions>) {
-  const {paramType, useType, expression, useValidation, useMapper, ...props} = options;
-
-  return [paramType !== ParamTypes.FILES && UseType(useType), useValidation && UseValidation(), useMapper && UseDeserialization(props)];
-}
-
-/**
- * Register a new param. It uses the paramType to extract value and give it to the next pipe.
- *
- * Given options allow to enable or disable following pipes:
- *
- * - useType: Add extra type for the json mapper,
- * - expression: Get property from the returned value by the previous pipe.
- * - useValidation: Apply validation from the returned value by the previous pipe.
- * - useMapper: Apply json mapper from the returned value by the previous pipe.
- *
- * @param options
- * @decorator
- * @operation
- * @input
- * @pipe
- */
-export function UseParam(options: Partial<ParamOptions>): ParameterDecorator {
-  return useDecorators(UseParamType(options as any), ...mapPipes(options)) as ParameterDecorator;
-}

package/src/decorators/useParamExpression.ts

@@ -1,16 +0,0 @@
-import {ParamFn} from "./paramFn.js";
-
-/**
- * Get data from a path inside the given object
- *
- * @param expression
- * @decorator
- * @operation
- * @input
- * @pipe
- */
-export function UseParamExpression(expression?: string) {
-  return ParamFn((param) => {
-    param.expression = expression || "";
-  });
-}

package/src/decorators/useParamType.ts

@@ -1,36 +0,0 @@
-import {isBuffer, useDecorators} from "@tsed/core";
-import {isParameterType, Name} from "@tsed/schema";
-
-import {ParamOptions} from "../domain/ParamOptions.js";
-import {PARAM_TYPES_DATA_PATH, ParamTypes} from "../domain/ParamTypes.js";
-import {ParamFn} from "./paramFn.js";
-import {UseParamExpression} from "./useParamExpression.js";
-
-/**
- * Get the object from request (like body, params, query, etc...).
- *
- * @decorator
- * @operation
- * @input
- * @pipe
- */
-export function UseParamType(options: ParamOptions) {
-  return useDecorators(
-    ParamFn((param) => {
-      if (isParameterType(options.paramType)) {
-        param.parameter!.in(options.paramType);
-      }
-
-      param.paramType = options.paramType;
-
-      if (isBuffer(param.type) || isBuffer(options.useType) || options.paramType === ParamTypes.RAW_BODY) {
-        param.paramType = ParamTypes.RAW_BODY;
-        param.parent.operation?.consumes(["*/*"]);
-      }
-
-      param.dataPath = options.dataPath || PARAM_TYPES_DATA_PATH[param.paramType] || "$ctx";
-    }),
-    options.expression && UseParamExpression(options.expression),
-    options.expression && Name(options.expression)
-  );
-}

package/src/decorators/usePipe.ts

@@ -1,21 +0,0 @@
-import {Type} from "@tsed/core";
-import {PipeMethods} from "@tsed/schema";
-
-import {ParamFn} from "./paramFn.js";
-
-/**
- * Register a Pipe to be used with the current decorated param.
- *
- * @param token
- * @param options
- * @decorator
- * @operation
- * @input
- * @pipe
- */
-export function UsePipe(token: Type<PipeMethods>, options: any = {}) {
-  return ParamFn((param) => {
-    param.store.set(token, options);
-    param.pipes.push(token);
-  });
-}

package/src/decorators/useType.ts

@@ -1,35 +0,0 @@
-import {Type} from "@tsed/core";
-import {Any, CollectionOf, type JsonParameterStore} from "@tsed/schema";
-
-import {ParamFn} from "./paramFn.js";
-
-function shouldFallBackToAny(entity: JsonParameterStore) {
-  if (entity.itemSchema.has("allOf") || entity.itemSchema.has("anyOf") || entity.itemSchema.has("oneOf")) {
-    return false;
-  }
-
-  return entity.isCollection && entity.type === Object && [undefined, "object"].includes(entity.itemSchema.get("type"));
-}
-
-/**
- * Set the type of the item collection.
- *
- * Prefer @@CollectionOf@@ usage.
- *
- * @param useType
- * @decorator
- * @operation
- * @input
- * @alias CollectionOf
- */
-export function UseType(useType: undefined | any | Type<any>) {
-  return ParamFn((entity, parameters) => {
-    if (useType) {
-      return CollectionOf(useType);
-    }
-
-    if (shouldFallBackToAny(entity)) {
-      Any()(...parameters);
-    }
-  });
-}

package/src/decorators/useValidation.ts

@@ -1,18 +0,0 @@
-import {ValidationPipe} from "../pipes/ValidationPipe.js";
-import {ParamFn} from "./paramFn.js";
-
-/**
- * Enable validation on the decoratored parameter.
- *
- * @decorator
- * @operation
- * @input
- * @pipe
- */
-export function UseValidation() {
-  return ParamFn((param) => {
-    if (param.type || param.collectionType) {
-      param.pipes.push(ValidationPipe);
-    }
-  });
-}

package/src/domain/ParamMetadata.ts

@@ -1 +0,0 @@
-export {ParamMetadata} from "@tsed/schema";

package/src/domain/ParamOptions.ts

@@ -1,12 +0,0 @@
-import {Type} from "@tsed/core";
-
-export interface ParamOptions<T = any> {
-  dataPath: string;
-  paramType: string;
-  expression?: string;
-  useType?: Type<T>;
-  useMapper?: boolean;
-  useValidation?: boolean;
-
-  [key: string]: any;
-}

package/src/domain/ParamTypes.ts

@@ -1,37 +0,0 @@
-export enum ParamTypes {
-  $CTX = "$CTX",
-  BODY = "BODY",
-  PATH = "PATH",
-  QUERY = "QUERY",
-  HEADER = "HEADER",
-  RAW_BODY = "RAW_BODY",
-  COOKIES = "COOKIES",
-  LOCALS = "LOCALS",
-  SESSION = "SESSION",
-  FILES = "FILES",
-
-  /// NOT STD
-  NEXT_FN = "NEXT_FN",
-  ERR = "ERR",
-  REQUEST = "REQUEST",
-  PLATFORM_REQUEST = "PLATFORM_REQUEST",
-  NODE_REQUEST = "NODE_REQUEST",
-  RESPONSE = "RESPONSE",
-  PLATFORM_RESPONSE = "PLATFORM_RESPONSE",
-  NODE_RESPONSE = "NODE_RESPONSE",
-  RESPONSE_DATA = "RESPONSE_DATA",
-  ENDPOINT_INFO = "ENDPOINT_INFO",
-  RES = "RES",
-  REQ = "REQ"
-}
-
-export const PARAM_TYPES_DATA_PATH: Record<string, string> = {
-  [ParamTypes.HEADER]: "$ctx.request.headers",
-  [ParamTypes.RAW_BODY]: "$ctx.request.rawBody",
-  [ParamTypes.BODY]: "$ctx.request.body",
-  [ParamTypes.QUERY]: "$ctx.request.query",
-  [ParamTypes.PATH]: "$ctx.request.params",
-  [ParamTypes.COOKIES]: "$ctx.request.cookies",
-  [ParamTypes.SESSION]: "$ctx.request.session",
-  [ParamTypes.LOCALS]: "$ctx.response.locals"
-};

package/src/errors/ParamValidationError.spec.ts

@@ -1,152 +0,0 @@
-import {ParamValidationError} from "./ParamValidationError.js";
-import {RequiredValidationError} from "./RequiredValidationError.js";
-import {ValidationError} from "./ValidationError.js";
-
-describe("ParseExpressionError", () => {
-  it("should return error without transformation", () => {
-    expect(ParamValidationError.from({} as any, new Error("error")).message).toEqual("error");
-  });
-  it("should return error", () => {
-    const validationError = new ValidationError("message");
-
-    const error = ParamValidationError.from(
-      {
-        paramType: "name",
-        expression: "expression"
-      } as any,
-      validationError
-    );
-    expect(error.message).toEqual('Bad request on parameter "request.name.expression".\nmessage');
-    expect(error.name).toEqual("PARAM_VALIDATION_ERROR");
-    expect(error.dataPath).toEqual("expression");
-    expect(error.requestType).toEqual("name");
-    expect({
-      name: error.name,
-      status: error.status,
-      headers: error.headers,
-      type: error.type,
-      message: error.message,
-      dataPath: error.dataPath,
-      requestType: error.requestType,
-      origin: {
-        name: error.origin.name,
-        status: error.origin.status,
-        headers: error.origin.headers,
-        type: error.origin.type,
-        message: error.origin.message,
-        errors: error.origin.errors
-      }
-    }).toEqual({
-      dataPath: "expression",
-      headers: {},
-      name: "PARAM_VALIDATION_ERROR",
-      requestType: "name",
-      status: 400,
-      type: "HTTP_EXCEPTION",
-      message: 'Bad request on parameter "request.name.expression".\nmessage',
-      origin: {
-        errors: [],
-        headers: {},
-        message: "message",
-        name: "VALIDATION_ERROR",
-        status: 400,
-        type: "HTTP_EXCEPTION"
-      }
-    });
-  });
-  it("should throw error from origin error (RequiredValidationError)", () => {
-    const metadata = {
-      paramType: "name",
-      expression: "expression"
-    } as any;
-    const origin = RequiredValidationError.from(metadata);
-
-    const error = ParamValidationError.from(metadata, origin);
-    expect(error.message).toEqual("Bad request on parameter \"request.name.expression\".\nIt should have required parameter 'expression'");
-    expect(error.dataPath).toEqual("expression");
-    expect(error.requestType).toEqual("name");
-
-    expect({
-      ...error,
-      message: error.message,
-      origin: {
-        ...error.origin,
-        message: error.origin.message
-      }
-    }).toEqual({
-      dataPath: "expression",
-      headers: {},
-      name: "PARAM_VALIDATION_ERROR",
-      message: "Bad request on parameter \"request.name.expression\".\nIt should have required parameter 'expression'",
-      origin: {
-        errors: [
-          {
-            requestPath: "name",
-            dataPath: ".expression",
-            keyword: "required",
-            message: "It should have required parameter 'expression'",
-            modelName: "name",
-            params: {
-              missingProperty: "expression"
-            },
-            schemaPath: "#/required"
-          }
-        ],
-        headers: {},
-        name: "REQUIRED_VALIDATION_ERROR",
-        message: "It should have required parameter 'expression'",
-        status: 400,
-        type: "HTTP_EXCEPTION"
-      },
-      requestType: "name",
-      status: 400,
-      type: "HTTP_EXCEPTION"
-    });
-  });
-  it("should throw error from origin error (ValidationError)", () => {
-    const metadata = {
-      paramType: "name",
-      expression: "expression"
-    } as any;
-    const origin = new ValidationError("It should have 1 item", [
-      {
-        dataPath: "hello"
-      }
-    ]);
-
-    const error = ParamValidationError.from(metadata, origin);
-    expect(error.message).toEqual('Bad request on parameter "request.name.expression".\nIt should have 1 item');
-    expect(error.dataPath).toEqual("expression");
-    expect(error.requestType).toEqual("name");
-
-    expect({
-      ...error,
-      message: error.message,
-      origin: {
-        ...error.origin,
-        message: error.origin.message
-      }
-    }).toEqual({
-      dataPath: "expression",
-      headers: {},
-      name: "PARAM_VALIDATION_ERROR",
-      origin: {
-        errors: [
-          {
-            requestPath: "name",
-            dataPath: "hello"
-          }
-        ],
-        headers: {},
-        message: "It should have 1 item",
-        name: "VALIDATION_ERROR",
-        status: 400,
-        type: "HTTP_EXCEPTION"
-      },
-      message: 'Bad request on parameter "request.name.expression".\nIt should have 1 item',
-      requestType: "name",
-      status: 400,
-      type: "HTTP_EXCEPTION"
-    });
-  });
-});

package/src/errors/ParamValidationError.ts

@@ -1,38 +0,0 @@
-import {nameOf} from "@tsed/core";
-import {BadRequest} from "@tsed/exceptions";
-import {JsonParameterStore} from "@tsed/schema";
-
-import {ValidationError} from "./ValidationError.js";
-
-export class ParamValidationError extends BadRequest {
-  public name: string = "PARAM_VALIDATION_ERROR";
-  public dataPath: string;
-  public requestType: string;
-
-  static from(metadata: JsonParameterStore, origin: any = {}) {
-    if (origin instanceof ValidationError || origin instanceof BadRequest) {
-      const name = nameOf(metadata.paramType)
-        .toLowerCase()
-        .replace(/parse|params|filter/gi, "");
-      const expression = metadata.expression;
-      const dataPath = `${name}${expression ? "." + expression : ""}`;
-      const message = `Bad request on parameter "request.${dataPath}".\n${origin.message}`.trim();
-
-      const error = new ParamValidationError(message);
-      error.dataPath = String(metadata.expression) || "";
-      error.requestType = nameOf(metadata.paramType);
-      error.origin = origin.origin || origin;
-
-      if (error.origin?.errors) {
-        error.origin?.errors.forEach((error: any) => {
-          error.requestPath = name;
-          error.dataPath = error.dataPath || (expression ? `.${expression}` : "");
-        });
-      }
-
-      return error;
-    }
-
-    return origin;
-  }
-}

package/src/errors/RequiredValidationError.spec.ts

@@ -1,49 +0,0 @@
-import {RequiredValidationError} from "./RequiredValidationError.js";
-
-describe("RequiredValidationError", () => {
-  it("should have a message", () => {
-    const error = RequiredValidationError.from({
-      paramType: "name",
-      expression: "expression"
-    } as any);
-    expect(error.message).toEqual("It should have required parameter 'expression'");
-    expect(error.name).toEqual("REQUIRED_VALIDATION_ERROR");
-    expect({
-      name: error.name,
-      status: error.status,
-      headers: error.headers,
-      type: error.type,
-      message: error.message,
-      errors: [
-        {
-          dataPath: error.errors[0].dataPath,
-          keyword: error.errors[0].keyword,
-          message: error.errors[0].message,
-          modelName: error.errors[0].modelName,
-          params: {
-            missingProperty: error.errors[0].params.missingProperty
-          },
-          schemaPath: error.errors[0].schemaPath
-        }
-      ]
-    }).toEqual({
-      name: "REQUIRED_VALIDATION_ERROR",
-      status: 400,
-      headers: {},
-      type: "HTTP_EXCEPTION",
-      message: "It should have required parameter 'expression'",
-      errors: [
-        {
-          dataPath: "",
-          keyword: "required",
-          message: "It should have required parameter 'expression'",
-          modelName: "name",
-          params: {
-            missingProperty: "expression"
-          },
-          schemaPath: "#/required"
-        }
-      ]
-    });
-  });
-});

package/src/errors/RequiredValidationError.ts

@@ -1,30 +0,0 @@
-import {nameOf} from "@tsed/core";
-import {JsonParameterStore} from "@tsed/schema";
-
-import {ValidationError} from "./ValidationError.js";
-
-export class RequiredValidationError extends ValidationError {
-  public name: string = "REQUIRED_VALIDATION_ERROR";
-
-  static from(metadata: JsonParameterStore) {
-    const name = nameOf(metadata.paramType);
-    const expression = metadata.expression;
-    const type = name.toLowerCase().replace(/parse|params|filter/gi, "");
-    const message = `It should have required parameter '${expression}'`;
-
-    const errors = [
-      {
-        dataPath: "",
-        keyword: "required",
-        message,
-        modelName: type,
-        params: {
-          missingProperty: expression
-        },
-        schemaPath: "#/required"
-      }
-    ];
-
-    return new RequiredValidationError(message, errors);
-  }
-}

package/src/errors/ValidationError.spec.ts

@@ -1,18 +0,0 @@
-import {ValidationError} from "./ValidationError.js";
-
-describe("ValidationError", () => {
-  it("should return error", () => {
-    const error = new ValidationError("should have required property", [
-      {
-        dataPath: "hello"
-      }
-    ]);
-
-    expect(error.errors).toEqual([
-      {
-        dataPath: "hello"
-      }
-    ]);
-    expect(error.message).toEqual("should have required property");
-  });
-});

package/src/errors/ValidationError.ts

@@ -1,11 +0,0 @@
-import {BadRequest} from "@tsed/exceptions";
-
-export class ValidationError extends BadRequest {
-  public name: string = "VALIDATION_ERROR";
-  public errors: any[];
-
-  constructor(message: string, errors: any[] = []) {
-    super(message);
-    this.errors = errors;
-  }
-}

package/src/exports.ts

@@ -1 +0,0 @@
-export {PipeMethods} from "@tsed/schema";

package/src/index.ts

@@ -1,31 +0,0 @@
-/**
- * @file Automatically generated by @tsed/barrels.
- */
-export * from "./builder/PlatformParams.js";
-export * from "./decorators/bodyParams.js";
-export * from "./decorators/context.js";
-export * from "./decorators/cookies.js";
-export * from "./decorators/headerParams.js";
-export * from "./decorators/locals.js";
-export * from "./decorators/paramFn.js";
-export * from "./decorators/pathParams.js";
-export * from "./decorators/queryParams.js";
-export * from "./decorators/session.js";
-export * from "./decorators/useDeserialization.js";
-export * from "./decorators/useParam.js";
-export * from "./decorators/useParamExpression.js";
-export * from "./decorators/useParamType.js";
-export * from "./decorators/usePipe.js";
-export * from "./decorators/useType.js";
-export * from "./decorators/useValidation.js";
-export * from "./domain/ParamMetadata.js";
-export * from "./domain/ParamOptions.js";
-export * from "./domain/ParamTypes.js";
-export * from "./errors/ParamValidationError.js";
-export * from "./errors/RequiredValidationError.js";
-export * from "./errors/ValidationError.js";
-export * from "./exports.js";
-export * from "./pipes/DeserializerPipe.js";
-export * from "./pipes/ParseExpressionPipe.js";
-export * from "./pipes/ValidationPipe.js";
-export * from "./utils/mapParamsOptions.js";

package/src/pipes/DeserializerPipe.spec.ts

@@ -1,39 +0,0 @@
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {JsonParameterStore} from "@tsed/schema";
-
-import {BodyParams} from "../decorators/bodyParams.js";
-import {QueryParams} from "../decorators/queryParams.js";
-import {DeserializerPipe} from "./DeserializerPipe.js";
-
-describe("DeserializerPipe", () => {
-  beforeEach(PlatformTest.create);
-  afterEach(PlatformTest.reset);
-  it("should transform an object to a model", async () => {
-    const pipe = await PlatformTest.get<DeserializerPipe>(DeserializerPipe);
-
-    class Test {
-      test(@BodyParams(String) input: string[]) {}
-    }
-
-    const param = JsonParameterStore.get(Test, "test", 0);
-
-    // WHEN
-    const result = pipe.transform(["test"], param);
-
-    expect(result).toEqual(["test"]);
-  });
-  it("should transform an object to a model (Query)", async () => {
-    const pipe = await PlatformTest.get<DeserializerPipe>(DeserializerPipe);
-
-    class Test {
-      test(@QueryParams("test", String) input: string[]) {}
-    }
-
-    const param = JsonParameterStore.get(Test, "test", 0);
-
-    // WHEN
-    const result = pipe.transform(["test"], param);
-
-    expect(result).toEqual(["test"]);
-  });
-});