@tsed/platform-params 8.0.1 → 8.0.3

package/src/errors/ParamValidationError.ts

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

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

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

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

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

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

package/src/index.ts

@@ -0,0 +1,31 @@
+/**
+ * @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

@@ -0,0 +1,39 @@
+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"]);
+  });
+});

package/src/pipes/DeserializerPipe.ts

@@ -0,0 +1,15 @@
+import {Injectable, injectable} from "@tsed/di";
+import {deserialize} from "@tsed/json-mapper";
+import {JsonParameterStore, PipeMethods} from "@tsed/schema";
+
+export class DeserializerPipe implements PipeMethods {
+  transform(value: any, param: JsonParameterStore) {
+    return deserialize(value, {
+      useAlias: true,
+      store: param,
+      ...(param.store.get(DeserializerPipe) || {})
+    });
+  }
+}
+
+injectable(DeserializerPipe);

package/src/pipes/ParseExpressionPipe.spec.ts

@@ -0,0 +1,242 @@
+import {DecoratorTypes} from "@tsed/core";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {JsonParameterStore} from "@tsed/schema";
+
+import {ParamTypes} from "../../src/index.js";
+import {ParseExpressionPipe} from "./ParseExpressionPipe.js";
+
+describe("ParseExpressionPipe", () => {
+  beforeEach(PlatformTest.create);
+  beforeEach(PlatformTest.reset);
+  it(
+    "should parse expression",
+    PlatformTest.inject([ParseExpressionPipe], (pipe: ParseExpressionPipe) => {
+      // @ts-ignore
+      class Test {}
+
+      const param: any = new JsonParameterStore({
+        index: 0,
+        target: Test,
+        propertyKey: "test",
+        expression: "test",
+        paramType: ParamTypes.REQUEST,
+        dataPath: "$ctx.request",
+        decoratorType: DecoratorTypes.PARAM
+      });
+      // @ts-ignore
+      param._type = String;
+      param.collectionType = Array;
+
+      const scope: any = {
+        $ctx: {
+          request: {
+            test: "value"
+          }
+        }
+      };
+
+      // WHEN
+      const value = pipe.transform(scope, param);
+
+      expect(value).toEqual("value");
+    })
+  );
+  it(
+    "should return empty value",
+    PlatformTest.inject([ParseExpressionPipe], (pipe: ParseExpressionPipe) => {
+      // @ts-ignore
+      class Test {}
+
+      const param: any = new JsonParameterStore({
+        index: 0,
+        target: Test,
+        propertyKey: "test",
+        expression: "test",
+        paramType: ParamTypes.REQUEST,
+        dataPath: "$ctx.request",
+        decoratorType: DecoratorTypes.PARAM
+      });
+      // @ts-ignore
+      param._type = String;
+      param.collectionType = Array;
+
+      const scope: any = {
+        $ctx: {
+          request: {}
+        }
+      };
+
+      // WHEN
+      const value = pipe.transform(scope, param);
+
+      expect(value).toEqual(undefined);
+    })
+  );
+  it(
+    "should parse expression (for HEADER)",
+    PlatformTest.inject([ParseExpressionPipe], (pipe: ParseExpressionPipe) => {
+      // @ts-ignore
+      class Test {}
+
+      const param: any = new JsonParameterStore({
+        index: 0,
+        target: Test,
+        propertyKey: "test",
+        expression: "Content-Type",
+        paramType: ParamTypes.HEADER,
+        dataPath: "$ctx.request.headers",
+        decoratorType: DecoratorTypes.PARAM
+      });
+      // @ts-ignore
+      param._type = String;
+      param.collectionType = Array;
+
+      const scope: any = {
+        $ctx: {
+          request: {
+            headers: {
+              "content-type": "application/json"
+            }
+          }
+        }
+      };
+      // WHEN
+      const value = pipe.transform(scope, param);
+
+      expect(value).toEqual("application/json");
+    })
+  );
+  it(
+    "should return undefined when value is empty and Boolean (for QUERY)",
+    PlatformTest.inject([ParseExpressionPipe], (pipe: ParseExpressionPipe) => {
+      // @ts-ignore
+      class Test {}
+
+      const param = new JsonParameterStore({
+        index: 0,
+        target: Test,
+        propertyKey: "test",
+        expression: "test",
+        paramType: ParamTypes.QUERY,
+        dataPath: "$ctx.request.query",
+        decoratorType: DecoratorTypes.PARAM
+      });
+      // @ts-ignore
+      param._type = Boolean;
+
+      const scope: any = {
+        $ctx: {
+          request: {
+            query: {
+              test: ""
+            }
+          }
+        }
+      };
+
+      // WHEN
+      const value = pipe.transform(scope, param);
+
+      expect(value).toEqual(undefined);
+    })
+  );
+  it(
+    "should return empty when value is empty and String (for QUERY)",
+    PlatformTest.inject([ParseExpressionPipe], (pipe: ParseExpressionPipe) => {
+      // @ts-ignore
+      class Test {}
+
+      const param = new JsonParameterStore({
+        index: 0,
+        target: Test,
+        propertyKey: "test",
+        expression: "test",
+        paramType: ParamTypes.QUERY,
+        dataPath: "$ctx.request.query",
+        decoratorType: DecoratorTypes.PARAM
+      });
+
+      const scope: any = {
+        $ctx: {
+          request: {
+            query: {
+              test: ""
+            }
+          }
+        }
+      };
+      // @ts-ignore
+      param._type = String;
+      // WHEN
+      const value = pipe.transform(scope, param);
+
+      expect(value).toEqual("");
+    })
+  );
+  it(
+    "should return undefined when value is empty and Boolean (for PATH)",
+    PlatformTest.inject([ParseExpressionPipe], (pipe: ParseExpressionPipe) => {
+      // @ts-ignore
+      class Test {}
+
+      const param = new JsonParameterStore({
+        index: 0,
+        target: Test,
+        propertyKey: "test",
+        expression: "test",
+        paramType: ParamTypes.PATH,
+        dataPath: "$ctx.request.params",
+        decoratorType: DecoratorTypes.PARAM
+      });
+      // @ts-ignore
+      param._type = Boolean;
+
+      const scope: any = {
+        $ctx: {
+          request: {
+            params: {
+              test: ""
+            }
+          }
+        }
+      };
+      // WHEN
+      const value = pipe.transform(scope, param);
+
+      expect(value).toEqual(undefined);
+    })
+  );
+  it(
+    "should return empty when value is empty and String (for PATH)",
+    PlatformTest.inject([ParseExpressionPipe], (pipe: ParseExpressionPipe) => {
+      // @ts-ignore
+      class Test {}
+
+      const param = new JsonParameterStore({
+        index: 0,
+        target: Test,
+        propertyKey: "test",
+        expression: "test",
+        paramType: ParamTypes.PATH,
+        dataPath: "$ctx.request.params",
+        decoratorType: DecoratorTypes.PARAM
+      });
+      // @ts-ignore
+      param._type = String;
+
+      const scope: any = {
+        $ctx: {
+          request: {
+            params: {
+              test: ""
+            }
+          }
+        }
+      };
+      // WHEN
+      const value = pipe.transform(scope, param);
+
+      expect(value).toEqual("");
+    })
+  );
+});

package/src/pipes/ParseExpressionPipe.ts

@@ -0,0 +1,33 @@
+import {getValue} from "@tsed/core";
+import {Injectable, injectable} from "@tsed/di";
+import {JsonParameterStore, PipeMethods} from "@tsed/schema";
+
+import {PlatformParamsScope} from "../builder/PlatformParams.js";
+import {ParamTypes} from "../domain/ParamTypes.js";
+
+export class ParseExpressionPipe implements PipeMethods {
+  transform(scope: PlatformParamsScope, param: JsonParameterStore) {
+    const {paramType, type} = param;
+
+    const value = getValue(scope, this.getKey(param));
+
+    if ([ParamTypes.QUERY, ParamTypes.PATH].includes(paramType as ParamTypes) && value === "" && type !== String) {
+      return undefined;
+    }
+
+    return value;
+  }
+
+  protected getKey(param: JsonParameterStore) {
+    let {expression, paramType, dataPath} = param;
+    paramType = paramType || param.parameter.get("in").toUpperCase();
+
+    if (expression && paramType === ParamTypes.HEADER) {
+      expression = String(expression).toLowerCase();
+    }
+
+    return [dataPath, expression].filter(Boolean).join(".");
+  }
+}
+
+injectable(ParseExpressionPipe).priority(-1000);