@nestia/core 4.4.1 → 4.4.2-dev.20241217

package/src/decorators/internal/route_error.ts

@@ -1,45 +1,45 @@
-import { HttpException } from "@nestjs/common";
-import express from "express";
-import type { FastifyRequest } from "fastify";
-import { throwError } from "rxjs";
-
-import { ExceptionManager } from "../../utils/ExceptionManager";
-
-/**
- * @internal
- */
-export function route_error(
-  request: express.Request | FastifyRequest,
-  error: any,
-) {
-  error = (() => {
-    // HTTP-ERROR
-    if (error instanceof HttpException) return error;
-
-    // CUSTOM-REGISTERED ERROR
-    for (const [creator, closure] of ExceptionManager.tuples)
-      if (error instanceof creator) return closure(error);
-
-    // MAYBE INTERNAL ERROR
-    return error;
-  })();
-
-  try {
-    error.method = request.method;
-    error.path =
-      (request as express.Request).path ??
-      (request as FastifyRequest).routeOptions?.url ??
-      (request as FastifyRequest).routerPath;
-  } catch {}
-
-  setTimeout(() => {
-    for (const listener of ExceptionManager.listeners) {
-      try {
-        const res: any | Promise<any> = listener(error);
-        if (typeof res === "object" && typeof res.catch === "function")
-          res.catch(() => {});
-      } catch {}
-    }
-  }, 0);
-  return throwError(() => error);
-}
+import { HttpException } from "@nestjs/common";
+import express from "express";
+import type { FastifyRequest } from "fastify";
+import { throwError } from "rxjs";
+
+import { ExceptionManager } from "../../utils/ExceptionManager";
+
+/**
+ * @internal
+ */
+export function route_error(
+  request: express.Request | FastifyRequest,
+  error: any,
+) {
+  error = (() => {
+    // HTTP-ERROR
+    if (error instanceof HttpException) return error;
+
+    // CUSTOM-REGISTERED ERROR
+    for (const [creator, closure] of ExceptionManager.tuples)
+      if (error instanceof creator) return closure(error);
+
+    // MAYBE INTERNAL ERROR
+    return error;
+  })();
+
+  try {
+    error.method = request.method;
+    error.path =
+      (request as express.Request).path ??
+      (request as FastifyRequest).routeOptions?.url ??
+      (request as FastifyRequest).routerPath;
+  } catch {}
+
+  setTimeout(() => {
+    for (const listener of ExceptionManager.listeners) {
+      try {
+        const res: any | Promise<any> = listener(error);
+        if (typeof res === "object" && typeof res.catch === "function")
+          res.catch(() => {});
+      } catch {}
+    }
+  }, 0);
+  return throwError(() => error);
+}

package/src/decorators/internal/validate_request_body.ts

@@ -1,74 +1,74 @@
-import { BadRequestException } from "@nestjs/common";
-import typia, { IValidation, TypeGuardError } from "typia";
-
-import { IRequestBodyValidator } from "../../options/IRequestBodyValidator";
-import { NoTransformConfigurationError } from "../NoTransformConfigurationError";
-
-/**
- * @internal
- */
-export const validate_request_body =
-  (method: string) =>
-  <T>(validator?: IRequestBodyValidator<T>): ((input: T) => Error | null) => {
-    if (!validator) {
-      NoTransformConfigurationError(method);
-      return () => null;
-    } 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);
-    return () =>
-      new Error(`Error on nestia.core.${method}(): invalid typed validator.`);
-  };
-
-/**
- * @internal
- */
-const assert =
-  <T>(closure: (data: T) => T) =>
-  (input: T) => {
-    try {
-      closure(input);
-      return null;
-    } catch (exp) {
-      if (typia.is<TypeGuardError>(exp)) {
-        return new BadRequestException({
-          path: exp.path,
-          reason: exp.message,
-          expected: exp.expected,
-          value: exp.value,
-          message: MESSAGE,
-        });
-      }
-      throw exp;
-    }
-  };
-
-/**
- * @internal
- */
-const is =
-  <T>(closure: (data: T) => boolean) =>
-  (input: T) => {
-    const success: boolean = closure(input);
-    return success ? null : new BadRequestException(MESSAGE);
-  };
-
-/**
- * @internal
- */
-const validate =
-  <T>(closure: (data: T) => IValidation<T>) =>
-  (input: T) => {
-    const result: IValidation<T> = closure(input);
-    return result.success
-      ? null
-      : new BadRequestException({
-          errors: result.errors,
-          message: MESSAGE,
-        });
-  };
-
-/**
- * @internal
- */
-const MESSAGE = "Request body data is not following the promised type.";
+import { BadRequestException } from "@nestjs/common";
+import typia, { IValidation, TypeGuardError } from "typia";
+
+import { IRequestBodyValidator } from "../../options/IRequestBodyValidator";
+import { NoTransformConfigurationError } from "../NoTransformConfigurationError";
+
+/**
+ * @internal
+ */
+export const validate_request_body =
+  (method: string) =>
+  <T>(validator?: IRequestBodyValidator<T>): ((input: T) => Error | null) => {
+    if (!validator) {
+      NoTransformConfigurationError(method);
+      return () => null;
+    } 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);
+    return () =>
+      new Error(`Error on nestia.core.${method}(): invalid typed validator.`);
+  };
+
+/**
+ * @internal
+ */
+const assert =
+  <T>(closure: (data: T) => T) =>
+  (input: T) => {
+    try {
+      closure(input);
+      return null;
+    } catch (exp) {
+      if (typia.is<TypeGuardError>(exp)) {
+        return new BadRequestException({
+          path: exp.path,
+          reason: exp.message,
+          expected: exp.expected,
+          value: exp.value,
+          message: MESSAGE,
+        });
+      }
+      throw exp;
+    }
+  };
+
+/**
+ * @internal
+ */
+const is =
+  <T>(closure: (data: T) => boolean) =>
+  (input: T) => {
+    const success: boolean = closure(input);
+    return success ? null : new BadRequestException(MESSAGE);
+  };
+
+/**
+ * @internal
+ */
+const validate =
+  <T>(closure: (data: T) => IValidation<T>) =>
+  (input: T) => {
+    const result: IValidation<T> = closure(input);
+    return result.success
+      ? null
+      : new BadRequestException({
+          errors: result.errors,
+          message: MESSAGE,
+        });
+  };
+
+/**
+ * @internal
+ */
+const MESSAGE = "Request body data is not following the promised type.";

package/src/decorators/internal/validate_request_form_data.ts

@@ -1,77 +1,77 @@
-import { BadRequestException } from "@nestjs/common";
-import typia, { IValidation, TypeGuardError } from "typia";
-
-import { IRequestFormDataProps } from "../../options/IRequestFormDataProps";
-import { NoTransformConfigurationError } from "../NoTransformConfigurationError";
-
-/**
- * @internal
- */
-export const validate_request_form_data = <T>(
-  props?: IRequestFormDataProps<T>,
-): ((value: FormData) => T | Error) => {
-  if (!props) {
-    NoTransformConfigurationError("TypedFormData.Body");
-    return (input: FormData) => Object.entries(input) as T;
-  } else if (props.validator.type === "assert")
-    return assert(props.validator.assert);
-  else if (props.validator.type === "is") return is(props.validator.is);
-  else if (props.validator.type === "validate")
-    return validate(props.validator.validate);
-  return () =>
-    new Error(
-      `Error on nestia.core.TypedFormData.Body(): invalid typed validator.`,
-    );
-};
-
-/**
- * @internal
- */
-const assert =
-  <T>(closure: (input: FormData) => T) =>
-  (input: FormData): T | BadRequestException => {
-    try {
-      return closure(input);
-    } catch (exp) {
-      if (typia.is<TypeGuardError>(exp)) {
-        return new BadRequestException({
-          path: exp.path,
-          reason: exp.message,
-          expected: exp.expected,
-          value: exp.value,
-          message: MESSAGE,
-        });
-      }
-      throw exp;
-    }
-  };
-
-/**
- * @internal
- */
-const is =
-  <T>(closure: (input: FormData) => T | null) =>
-  (input: FormData): T | BadRequestException => {
-    const result: T | null = closure(input);
-    return result !== null ? result : new BadRequestException(MESSAGE);
-  };
-
-/**
- * @internal
- */
-const validate =
-  <T>(closure: (input: FormData) => IValidation<T>) =>
-  (input: FormData): T | BadRequestException => {
-    const result: IValidation<T> = closure(input);
-    return result.success
-      ? result.data
-      : new BadRequestException({
-          errors: result.errors,
-          message: MESSAGE,
-        });
-  };
-
-/**
- * @internal
- */
-const MESSAGE = "Request multipart data is not following the promised type.";
+import { BadRequestException } from "@nestjs/common";
+import typia, { IValidation, TypeGuardError } from "typia";
+
+import { IRequestFormDataProps } from "../../options/IRequestFormDataProps";
+import { NoTransformConfigurationError } from "../NoTransformConfigurationError";
+
+/**
+ * @internal
+ */
+export const validate_request_form_data = <T>(
+  props?: IRequestFormDataProps<T>,
+): ((value: FormData) => T | Error) => {
+  if (!props) {
+    NoTransformConfigurationError("TypedFormData.Body");
+    return (input: FormData) => Object.entries(input) as T;
+  } else if (props.validator.type === "assert")
+    return assert(props.validator.assert);
+  else if (props.validator.type === "is") return is(props.validator.is);
+  else if (props.validator.type === "validate")
+    return validate(props.validator.validate);
+  return () =>
+    new Error(
+      `Error on nestia.core.TypedFormData.Body(): invalid typed validator.`,
+    );
+};
+
+/**
+ * @internal
+ */
+const assert =
+  <T>(closure: (input: FormData) => T) =>
+  (input: FormData): T | BadRequestException => {
+    try {
+      return closure(input);
+    } catch (exp) {
+      if (typia.is<TypeGuardError>(exp)) {
+        return new BadRequestException({
+          path: exp.path,
+          reason: exp.message,
+          expected: exp.expected,
+          value: exp.value,
+          message: MESSAGE,
+        });
+      }
+      throw exp;
+    }
+  };
+
+/**
+ * @internal
+ */
+const is =
+  <T>(closure: (input: FormData) => T | null) =>
+  (input: FormData): T | BadRequestException => {
+    const result: T | null = closure(input);
+    return result !== null ? result : new BadRequestException(MESSAGE);
+  };
+
+/**
+ * @internal
+ */
+const validate =
+  <T>(closure: (input: FormData) => IValidation<T>) =>
+  (input: FormData): T | BadRequestException => {
+    const result: IValidation<T> = closure(input);
+    return result.success
+      ? result.data
+      : new BadRequestException({
+          errors: result.errors,
+          message: MESSAGE,
+        });
+  };
+
+/**
+ * @internal
+ */
+const MESSAGE = "Request multipart data is not following the promised type.";

package/src/decorators/internal/validate_request_headers.ts

@@ -1,86 +1,86 @@
-import { BadRequestException } from "@nestjs/common";
-import typia, { IValidation, TypeGuardError } from "typia";
-
-import { IRequestHeadersValidator } from "../../options/IRequestHeadersValidator";
-import { NoTransformConfigurationError } from "../NoTransformConfigurationError";
-
-/**
- * @internal
- */
-export const validate_request_headers = <T>(
-  validator?: IRequestHeadersValidator<T>,
-): ((input: Record<string, string | string[] | undefined>) => T | Error) => {
-  if (!validator) {
-    NoTransformConfigurationError("TypedHeaders");
-    return (input: Record<string, string | string[] | undefined>) =>
-      Object.entries(input) as T;
-  } 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);
-  return () =>
-    new Error(`Error on nestia.core.TypedHeaders(): invalid typed validator.`);
-};
-
-/**
- * @internal
- */
-const assert =
-  <T>(closure: (input: Record<string, string | string[] | undefined>) => T) =>
-  (
-    input: Record<string, string | string[] | undefined>,
-  ): T | BadRequestException => {
-    try {
-      return closure(input);
-    } catch (exp) {
-      if (typia.is<TypeGuardError>(exp)) {
-        return new BadRequestException({
-          path: exp.path,
-          reason: exp.message,
-          expected: exp.expected,
-          value: exp.value,
-          message: MESSAGE,
-        });
-      }
-      throw exp;
-    }
-  };
-
-/**
- * @internal
- */
-const is =
-  <T>(
-    closure: (input: Record<string, string | string[] | undefined>) => T | null,
-  ) =>
-  (
-    input: Record<string, string | string[] | undefined>,
-  ): T | BadRequestException => {
-    const result: T | null = closure(input);
-    return result !== null ? result : new BadRequestException(MESSAGE);
-  };
-
-/**
- * @internal
- */
-const validate =
-  <T>(
-    closure: (
-      input: Record<string, string | string[] | undefined>,
-    ) => IValidation<T>,
-  ) =>
-  (
-    input: Record<string, string | string[] | undefined>,
-  ): T | BadRequestException => {
-    const result: IValidation<T> = closure(input);
-    return result.success
-      ? result.data
-      : new BadRequestException({
-          errors: result.errors,
-          message: MESSAGE,
-        });
-  };
-
-/**
- * @internal
- */
-const MESSAGE = "Request headers data is not following the promised type.";
+import { BadRequestException } from "@nestjs/common";
+import typia, { IValidation, TypeGuardError } from "typia";
+
+import { IRequestHeadersValidator } from "../../options/IRequestHeadersValidator";
+import { NoTransformConfigurationError } from "../NoTransformConfigurationError";
+
+/**
+ * @internal
+ */
+export const validate_request_headers = <T>(
+  validator?: IRequestHeadersValidator<T>,
+): ((input: Record<string, string | string[] | undefined>) => T | Error) => {
+  if (!validator) {
+    NoTransformConfigurationError("TypedHeaders");
+    return (input: Record<string, string | string[] | undefined>) =>
+      Object.entries(input) as T;
+  } 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);
+  return () =>
+    new Error(`Error on nestia.core.TypedHeaders(): invalid typed validator.`);
+};
+
+/**
+ * @internal
+ */
+const assert =
+  <T>(closure: (input: Record<string, string | string[] | undefined>) => T) =>
+  (
+    input: Record<string, string | string[] | undefined>,
+  ): T | BadRequestException => {
+    try {
+      return closure(input);
+    } catch (exp) {
+      if (typia.is<TypeGuardError>(exp)) {
+        return new BadRequestException({
+          path: exp.path,
+          reason: exp.message,
+          expected: exp.expected,
+          value: exp.value,
+          message: MESSAGE,
+        });
+      }
+      throw exp;
+    }
+  };
+
+/**
+ * @internal
+ */
+const is =
+  <T>(
+    closure: (input: Record<string, string | string[] | undefined>) => T | null,
+  ) =>
+  (
+    input: Record<string, string | string[] | undefined>,
+  ): T | BadRequestException => {
+    const result: T | null = closure(input);
+    return result !== null ? result : new BadRequestException(MESSAGE);
+  };
+
+/**
+ * @internal
+ */
+const validate =
+  <T>(
+    closure: (
+      input: Record<string, string | string[] | undefined>,
+    ) => IValidation<T>,
+  ) =>
+  (
+    input: Record<string, string | string[] | undefined>,
+  ): T | BadRequestException => {
+    const result: IValidation<T> = closure(input);
+    return result.success
+      ? result.data
+      : new BadRequestException({
+          errors: result.errors,
+          message: MESSAGE,
+        });
+  };
+
+/**
+ * @internal
+ */
+const MESSAGE = "Request headers data is not following the promised type.";