@nestia/core 1.2.0-dev.20230504 → 1.2.1-dev.20230505

package/src/decorators/internal/validate_request_body.ts

@@ -1,6 +1,6 @@
 import { BadRequestException } from "@nestjs/common";
 
-import { IValidation, TypeGuardError } from "typia";
+import typia, { IValidation, TypeGuardError } from "typia";
 
 import { IRequestBodyValidator } from "../../options/IRequestBodyValidator";
 import { TransformError } from "./TransformError";
@@ -8,14 +8,15 @@ import { TransformError } from "./TransformError";
 export const validate_request_body =
     (method: string) =>
     <T>(validator?: IRequestBodyValidator<T>) => {
-        if (!validator) throw TransformError(method);
+        if (!validator) return () => TransformError(method);
         else if (validator.type === "assert") return assert(validator.assert);
         else if (validator.type === "is") return is(validator.is);
         else if (validator.type === "validate")
             return validate(validator.validate);
-        throw new Error(
-            `Error on nestia.core.${method}(): invalid typed validator.`,
-        );
+        return () =>
+            new Error(
+                `Error on nestia.core.${method}(): invalid typed validator.`,
+            );
     };
 
 const assert =
@@ -23,9 +24,10 @@ const assert =
     (data: T) => {
         try {
             closure(data);
+            return null;
         } catch (exp) {
-            if (exp instanceof TypeGuardError) {
-                throw new BadRequestException({
+            if (typia.is<TypeGuardError>(exp)) {
+                return new BadRequestException({
                     path: exp.path,
                     reason: exp.message,
                     expected: exp.expected,
@@ -41,18 +43,19 @@ const is =
     <T>(closure: (data: T) => boolean) =>
     (data: T) => {
         const success: boolean = closure(data);
-        if (success === false) throw new BadRequestException(MESSAGE);
+        return success ? null : new BadRequestException(MESSAGE);
     };
 
 const validate =
     <T>(closure: (data: T) => IValidation<T>) =>
     (data: T) => {
         const result: IValidation<T> = closure(data);
-        if (result.success === false)
-            throw new BadRequestException({
-                errors: result.errors,
-                message: MESSAGE,
-            });
+        return result.success
+            ? null
+            : new BadRequestException({
+                  errors: result.errors,
+                  message: MESSAGE,
+              });
     };
 
 const MESSAGE = "Request body data is not following the promised type.";