@nestia/core 4.4.2-dev.20241217 → 4.4.2

package/src/decorators/EncryptedRoute.ts

@@ -1,219 +1,219 @@
-import { AesPkcs5 } from "@nestia/fetcher/lib/AesPkcs5";
-import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
-import {
-  CallHandler,
-  Delete,
-  ExecutionContext,
-  Get,
-  NestInterceptor,
-  Patch,
-  Post,
-  Put,
-  UseInterceptors,
-  applyDecorators,
-} from "@nestjs/common";
-import { HttpArgumentsHost } from "@nestjs/common/interfaces";
-import express from "express";
-import { catchError, map } from "rxjs/operators";
-import typia from "typia";
-
-import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
-import { Singleton } from "../utils/Singleton";
-import { TypedRoute } from "./TypedRoute";
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
-import { get_path_and_stringify } from "./internal/get_path_and_stringify";
-import { headers_to_object } from "./internal/headers_to_object";
-import { route_error } from "./internal/route_error";
-
-/**
- * Encrypted router decorator functions.
- *
- * `EncryptedRoute` is a module containing router decorator functions which encrypts
- * response body data through AES-128/256 encryption. Furthermore, they can boost
- * up JSON string conversion speed about 50x times faster than `class-transformer`,
- * even type safe through [typia](https://github.com/samchon/typia).
- *
- * For reference, if you try to invalid data that is not following the promised
- * type `T`, 500 internal server error would be thrown. Also, as `EncryptedRoute`
- * composes JSON string through `typia.assertStringify<T>()` function, it is not
- * possible to modify response data through interceptors.
- *
- *  - AES-128/256
- *  - CBC mode
- *  - PKCS #5 Padding
- *  - Base64 Encoding
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace EncryptedRoute {
-  /**
-   * Encrypted router decorator function for the GET method.
-   *
-   * @param paths Path(s) of the HTTP request
-   * @returns Method decorator
-   */
-  export const Get = Generator("Get");
-
-  /**
-   * Encrypted router decorator function for the GET method.
-   *
-   * @param paths Path(s) of the HTTP request
-   * @returns Method decorator
-   */
-  export const Post = Generator("Post");
-
-  /**
-   * Encrypted router decorator function for the PATCH method.
-   *
-   * @param path Path of the HTTP request
-   * @returns Method decorator
-   */
-  export const Patch = Generator("Patch");
-
-  /**
-   * Encrypted router decorator function for the PUT method.
-   *
-   * @param path Path of the HTTP request
-   * @returns Method decorator
-   */
-  export const Put = Generator("Put");
-
-  /**
-   * Encrypted router decorator function for the DELETE method.
-   *
-   * @param path Path of the HTTP request
-   * @returns Method decorator
-   */
-  export const Delete = Generator("Delete");
-
-  /**
-   * Set the logger function for the response validation failure.
-   *
-   * If you've configured the transformation option to `validate.log`
-   * in the `tsconfig.json` file, then the error log information of the
-   * response validation failure would be logged through this function
-   * instead of throwing the 400 bad request error.
-   *
-   * By the way, be careful. If you've configured the response
-   * transformation option to be `validate.log`, client may get wrong
-   * response data. Therefore, this way is not recommended in the common
-   * backend server case.
-   *
-   * @param func Logger function
-   * @default console.log
-   */
-  export function setValidateErrorLogger(
-    func: (log: IValidateErrorLog) => void,
-  ): void {
-    TypedRoute.setValidateErrorLogger(func);
-  }
-
-  export import IValidateErrorLog = TypedRoute.IValidateErrorLog;
-
-  /**
-   * @internal
-   */
-  function Generator(method: "Get" | "Post" | "Put" | "Patch" | "Delete") {
-    function route(path?: string | string[]): MethodDecorator;
-    function route<T>(
-      stringify?: IResponseBodyStringifier<T> | null,
-    ): MethodDecorator;
-    function route<T>(
-      path: string | string[],
-      stringify?: IResponseBodyStringifier<T> | null,
-    ): MethodDecorator;
-
-    function route(...args: any[]): MethodDecorator {
-      const [path, stringify] = get_path_and_stringify(
-        () => TypedRoute.__logger,
-      )(`EncryptedRoute.${method}`)(...args);
-      return applyDecorators(
-        ROUTERS[method](path),
-        UseInterceptors(new EncryptedRouteInterceptor(method, stringify)),
-      );
-    }
-    return route;
-  }
-}
-
-for (const method of [
-  typia.json.isStringify,
-  typia.json.assertStringify,
-  typia.json.validateStringify,
-  typia.json.stringify,
-])
-  for (const [key, value] of Object.entries(method))
-    for (const deco of [
-      EncryptedRoute.Get,
-      EncryptedRoute.Delete,
-      EncryptedRoute.Post,
-      EncryptedRoute.Put,
-      EncryptedRoute.Patch,
-    ])
-      (deco as any)[key] = value;
-
-/**
- * @internal
- */
-class EncryptedRouteInterceptor implements NestInterceptor {
-  public constructor(
-    private readonly method: string,
-    private readonly stringify: (
-      input: any,
-      method: string,
-      path: string,
-    ) => string,
-  ) {}
-
-  public intercept(context: ExecutionContext, next: CallHandler) {
-    const http: HttpArgumentsHost = context.switchToHttp();
-    return next.handle().pipe(
-      map((value) => {
-        const param:
-          | IEncryptionPassword
-          | IEncryptionPassword.Closure
-          | undefined = Reflect.getMetadata(
-          ENCRYPTION_METADATA_KEY,
-          context.getClass(),
-        );
-        if (!param)
-          return Error(
-            `Error on EncryptedRoute.${this.method}(): no password found.`,
-          );
-
-        const request: express.Request = http.getRequest();
-        const headers: Singleton<Record<string, string>> = new Singleton(() =>
-          headers_to_object(request.headers),
-        );
-        const body: string | undefined = this.stringify(
-          value,
-          request.method,
-          request.url,
-        );
-        const password: IEncryptionPassword =
-          typeof param === "function"
-            ? param({
-                headers: headers.get(),
-                body,
-                direction: "encode",
-              })
-            : param;
-
-        if (body === undefined) return body;
-        return AesPkcs5.encrypt(body, password.key, password.iv);
-      }),
-      catchError((err) => route_error(http.getRequest(), err)),
-    );
-  }
-}
-
-/**
- * @internal
- */
-const ROUTERS = {
-  Get,
-  Post,
-  Put,
-  Patch,
-  Delete,
-};
+import { AesPkcs5 } from "@nestia/fetcher/lib/AesPkcs5";
+import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
+import {
+  CallHandler,
+  Delete,
+  ExecutionContext,
+  Get,
+  NestInterceptor,
+  Patch,
+  Post,
+  Put,
+  UseInterceptors,
+  applyDecorators,
+} from "@nestjs/common";
+import { HttpArgumentsHost } from "@nestjs/common/interfaces";
+import express from "express";
+import { catchError, map } from "rxjs/operators";
+import typia from "typia";
+
+import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
+import { Singleton } from "../utils/Singleton";
+import { TypedRoute } from "./TypedRoute";
+import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+import { get_path_and_stringify } from "./internal/get_path_and_stringify";
+import { headers_to_object } from "./internal/headers_to_object";
+import { route_error } from "./internal/route_error";
+
+/**
+ * Encrypted router decorator functions.
+ *
+ * `EncryptedRoute` is a module containing router decorator functions which encrypts
+ * response body data through AES-128/256 encryption. Furthermore, they can boost
+ * up JSON string conversion speed about 50x times faster than `class-transformer`,
+ * even type safe through [typia](https://github.com/samchon/typia).
+ *
+ * For reference, if you try to invalid data that is not following the promised
+ * type `T`, 500 internal server error would be thrown. Also, as `EncryptedRoute`
+ * composes JSON string through `typia.assertStringify<T>()` function, it is not
+ * possible to modify response data through interceptors.
+ *
+ *  - AES-128/256
+ *  - CBC mode
+ *  - PKCS #5 Padding
+ *  - Base64 Encoding
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace EncryptedRoute {
+  /**
+   * Encrypted router decorator function for the GET method.
+   *
+   * @param paths Path(s) of the HTTP request
+   * @returns Method decorator
+   */
+  export const Get = Generator("Get");
+
+  /**
+   * Encrypted router decorator function for the GET method.
+   *
+   * @param paths Path(s) of the HTTP request
+   * @returns Method decorator
+   */
+  export const Post = Generator("Post");
+
+  /**
+   * Encrypted router decorator function for the PATCH method.
+   *
+   * @param path Path of the HTTP request
+   * @returns Method decorator
+   */
+  export const Patch = Generator("Patch");
+
+  /**
+   * Encrypted router decorator function for the PUT method.
+   *
+   * @param path Path of the HTTP request
+   * @returns Method decorator
+   */
+  export const Put = Generator("Put");
+
+  /**
+   * Encrypted router decorator function for the DELETE method.
+   *
+   * @param path Path of the HTTP request
+   * @returns Method decorator
+   */
+  export const Delete = Generator("Delete");
+
+  /**
+   * Set the logger function for the response validation failure.
+   *
+   * If you've configured the transformation option to `validate.log`
+   * in the `tsconfig.json` file, then the error log information of the
+   * response validation failure would be logged through this function
+   * instead of throwing the 400 bad request error.
+   *
+   * By the way, be careful. If you've configured the response
+   * transformation option to be `validate.log`, client may get wrong
+   * response data. Therefore, this way is not recommended in the common
+   * backend server case.
+   *
+   * @param func Logger function
+   * @default console.log
+   */
+  export function setValidateErrorLogger(
+    func: (log: IValidateErrorLog) => void,
+  ): void {
+    TypedRoute.setValidateErrorLogger(func);
+  }
+
+  export import IValidateErrorLog = TypedRoute.IValidateErrorLog;
+
+  /**
+   * @internal
+   */
+  function Generator(method: "Get" | "Post" | "Put" | "Patch" | "Delete") {
+    function route(path?: string | string[]): MethodDecorator;
+    function route<T>(
+      stringify?: IResponseBodyStringifier<T> | null,
+    ): MethodDecorator;
+    function route<T>(
+      path: string | string[],
+      stringify?: IResponseBodyStringifier<T> | null,
+    ): MethodDecorator;
+
+    function route(...args: any[]): MethodDecorator {
+      const [path, stringify] = get_path_and_stringify(
+        () => TypedRoute.__logger,
+      )(`EncryptedRoute.${method}`)(...args);
+      return applyDecorators(
+        ROUTERS[method](path),
+        UseInterceptors(new EncryptedRouteInterceptor(method, stringify)),
+      );
+    }
+    return route;
+  }
+}
+
+for (const method of [
+  typia.json.isStringify,
+  typia.json.assertStringify,
+  typia.json.validateStringify,
+  typia.json.stringify,
+])
+  for (const [key, value] of Object.entries(method))
+    for (const deco of [
+      EncryptedRoute.Get,
+      EncryptedRoute.Delete,
+      EncryptedRoute.Post,
+      EncryptedRoute.Put,
+      EncryptedRoute.Patch,
+    ])
+      (deco as any)[key] = value;
+
+/**
+ * @internal
+ */
+class EncryptedRouteInterceptor implements NestInterceptor {
+  public constructor(
+    private readonly method: string,
+    private readonly stringify: (
+      input: any,
+      method: string,
+      path: string,
+    ) => string,
+  ) {}
+
+  public intercept(context: ExecutionContext, next: CallHandler) {
+    const http: HttpArgumentsHost = context.switchToHttp();
+    return next.handle().pipe(
+      map((value) => {
+        const param:
+          | IEncryptionPassword
+          | IEncryptionPassword.Closure
+          | undefined = Reflect.getMetadata(
+          ENCRYPTION_METADATA_KEY,
+          context.getClass(),
+        );
+        if (!param)
+          return Error(
+            `Error on EncryptedRoute.${this.method}(): no password found.`,
+          );
+
+        const request: express.Request = http.getRequest();
+        const headers: Singleton<Record<string, string>> = new Singleton(() =>
+          headers_to_object(request.headers),
+        );
+        const body: string | undefined = this.stringify(
+          value,
+          request.method,
+          request.url,
+        );
+        const password: IEncryptionPassword =
+          typeof param === "function"
+            ? param({
+                headers: headers.get(),
+                body,
+                direction: "encode",
+              })
+            : param;
+
+        if (body === undefined) return body;
+        return AesPkcs5.encrypt(body, password.key, password.iv);
+      }),
+      catchError((err) => route_error(http.getRequest(), err)),
+    );
+  }
+}
+
+/**
+ * @internal
+ */
+const ROUTERS = {
+  Get,
+  Post,
+  Put,
+  Patch,
+  Delete,
+};

package/src/decorators/NoTransformConfigurationError.ts

@@ -1,32 +1,32 @@
-export function NoTransformConfigurationError(method: string) {
-  if (NoTransformConfigurationError.throws === true)
-    throw new Error(
-      [
-        `Error on nestia.core.${method}(): no transform has been configured.`,
-        `Run "npx typia setup" command, or check if you're using non-standard TypeScript compiler like Babel or SWC.`,
-        `Otherwise you're running "npx nestia sdk/swagger" or similar, run "npx tsc" command to find the reason why.`,
-      ].join(" "),
-    );
-  return undefined as never;
-}
-export namespace NoTransformConfigurationError {
-  /**
-   * Whether to throw an error or not.
-   *
-   * If you set this value to `false`, {@link NoTransformConfigurationError} will
-   * not throw an error.
-   *
-   * Even if you've not configured the plugin transformer of `tsconfig.json` file,
-   * the error will not be thrown and the program will be continued. Instead, every
-   * validations and assertions will be skipped and the value will be returned as it is.
-   * Furthermore, unexpected behaviors may occur.
-   *
-   * Therefore, it is not recommended to set this value to `false` in production
-   * environment. Configure this value to be `false` only when you're debugging or testing.
-   *
-   * By the way, if you hope the `false` value to be set, you have to do it before the first.
-   * If you configure the `false` value after the `@nestia/core` decorator functions are
-   * composed, the value will not be applied and the error will be thrown.
-   */
-  export let throws = true;
-}
+export function NoTransformConfigurationError(method: string) {
+  if (NoTransformConfigurationError.throws === true)
+    throw new Error(
+      [
+        `Error on nestia.core.${method}(): no transform has been configured.`,
+        `Run "npx typia setup" command, or check if you're using non-standard TypeScript compiler like Babel or SWC.`,
+        `Otherwise you're running "npx nestia sdk/swagger" or similar, run "npx tsc" command to find the reason why.`,
+      ].join(" "),
+    );
+  return undefined as never;
+}
+export namespace NoTransformConfigurationError {
+  /**
+   * Whether to throw an error or not.
+   *
+   * If you set this value to `false`, {@link NoTransformConfigurationError} will
+   * not throw an error.
+   *
+   * Even if you've not configured the plugin transformer of `tsconfig.json` file,
+   * the error will not be thrown and the program will be continued. Instead, every
+   * validations and assertions will be skipped and the value will be returned as it is.
+   * Furthermore, unexpected behaviors may occur.
+   *
+   * Therefore, it is not recommended to set this value to `false` in production
+   * environment. Configure this value to be `false` only when you're debugging or testing.
+   *
+   * By the way, if you hope the `false` value to be set, you have to do it before the first.
+   * If you configure the `false` value after the `@nestia/core` decorator functions are
+   * composed, the value will not be applied and the error will be thrown.
+   */
+  export let throws = true;
+}

package/src/decorators/PlainBody.ts

@@ -1,79 +1,79 @@
-import {
-  BadRequestException,
-  ExecutionContext,
-  createParamDecorator,
-} from "@nestjs/common";
-import type express from "express";
-import type { FastifyRequest } from "fastify";
-
-import { get_text_body } from "./internal/get_text_body";
-import { is_request_body_undefined } from "./internal/is_request_body_undefined";
-import { validate_request_body } from "./internal/validate_request_body";
-
-/**
- * Plain body decorator.
- *
- * `PlainBody` is a decorator function getting full body text from the HTTP request.
- *
- * If you adjust the regular {@link Body} decorator function to the body parameter,
- * you can't get the full body text because the {@link Body} tries to convert the
- * body text to JSON object. Therefore, `@nestia/core` provides this `PlainBody`
- * decorator function to get the full body text.
- *
- * ```typescript
- * \@TypedRoute.Post("memo")
- * public store
- *     (
- *         \@PlainBody() body: string
- *     ): void;
- * ```
- *
- * @return Parameter decorator
- * @author Jeongho Nam - https://github.com/samchon
- */
-export function PlainBody(): ParameterDecorator;
-
-/**
- * @internal
- */
-export function PlainBody(
-  assert?: (input: unknown) => string,
-): ParameterDecorator {
-  const checker = assert
-    ? validate_request_body("PlainBody")({
-        type: "assert",
-        assert,
-      })
-    : null;
-  return createParamDecorator(async function PlainBody(
-    _data: any,
-    context: ExecutionContext,
-  ) {
-    const request: express.Request | FastifyRequest = context
-      .switchToHttp()
-      .getRequest();
-    if (
-      is_request_body_undefined(request) &&
-      (checker ?? (() => null))(undefined as any) === null
-    )
-      return undefined;
-    else if (!isTextPlain(request.headers["content-type"]))
-      throw new BadRequestException(`Request body type is not "text/plain".`);
-    const value: string = await get_text_body(request);
-    if (checker) {
-      const error: Error | null = checker(value);
-      if (error !== null) throw error;
-    }
-    return value;
-  })();
-}
-
-/**
- * @internal
- */
-const isTextPlain = (text?: string): boolean =>
-  text !== undefined &&
-  text
-    .split(";")
-    .map((str) => str.trim())
-    .some((str) => str === "text/plain");
+import {
+  BadRequestException,
+  ExecutionContext,
+  createParamDecorator,
+} from "@nestjs/common";
+import type express from "express";
+import type { FastifyRequest } from "fastify";
+
+import { get_text_body } from "./internal/get_text_body";
+import { is_request_body_undefined } from "./internal/is_request_body_undefined";
+import { validate_request_body } from "./internal/validate_request_body";
+
+/**
+ * Plain body decorator.
+ *
+ * `PlainBody` is a decorator function getting full body text from the HTTP request.
+ *
+ * If you adjust the regular {@link Body} decorator function to the body parameter,
+ * you can't get the full body text because the {@link Body} tries to convert the
+ * body text to JSON object. Therefore, `@nestia/core` provides this `PlainBody`
+ * decorator function to get the full body text.
+ *
+ * ```typescript
+ * \@TypedRoute.Post("memo")
+ * public store
+ *     (
+ *         \@PlainBody() body: string
+ *     ): void;
+ * ```
+ *
+ * @return Parameter decorator
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function PlainBody(): ParameterDecorator;
+
+/**
+ * @internal
+ */
+export function PlainBody(
+  assert?: (input: unknown) => string,
+): ParameterDecorator {
+  const checker = assert
+    ? validate_request_body("PlainBody")({
+        type: "assert",
+        assert,
+      })
+    : null;
+  return createParamDecorator(async function PlainBody(
+    _data: any,
+    context: ExecutionContext,
+  ) {
+    const request: express.Request | FastifyRequest = context
+      .switchToHttp()
+      .getRequest();
+    if (
+      is_request_body_undefined(request) &&
+      (checker ?? (() => null))(undefined as any) === null
+    )
+      return undefined;
+    else if (!isTextPlain(request.headers["content-type"]))
+      throw new BadRequestException(`Request body type is not "text/plain".`);
+    const value: string = await get_text_body(request);
+    if (checker) {
+      const error: Error | null = checker(value);
+      if (error !== null) throw error;
+    }
+    return value;
+  })();
+}
+
+/**
+ * @internal
+ */
+const isTextPlain = (text?: string): boolean =>
+  text !== undefined &&
+  text
+    .split(";")
+    .map((str) => str.trim())
+    .some((str) => str === "text/plain");