@nestia/core 2.4.2 → 2.4.3-dev.20231207

package/src/decorators/EncryptedRoute.ts

@@ -1,21 +1,20 @@
 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,
+  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";
@@ -47,145 +46,137 @@ import { route_error } from "./internal/route_error";
  * @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");
-
-    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(
-                `EncryptedRoute.${method}`,
-            )(...args);
-            return applyDecorators(
-                ROUTERS[method](path),
-                UseInterceptors(
-                    new EncryptedRouteInterceptor(method, stringify),
-                ),
-            );
-        }
-        return route;
+  /**
+   * 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");
+
+  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(
+        `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,
+  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;
+  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) => 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)
-                    throw NoTransformConfigureError(
-                        `EncryptedRoute.${this.method}`,
-                    );
-
-                const headers: Singleton<Record<string, string>> =
-                    new Singleton(() => {
-                        const request: express.Request = http.getRequest();
-                        return headers_to_object(request.headers);
-                    });
-                const body: string | undefined = this.stringify(value);
-                const password: IEncryptionPassword =
-                    typeof param === "function"
-                        ? param({
-                              headers: headers.get(),
-                              body,
-                              direction: "encode",
-                          })
-                        : param;
-
-                const response: express.Response = http.getResponse();
-                response.header("Content-Type", "text/plain");
-
-                if (body === undefined) return body;
-                return AesPkcs5.encrypt(body, password.key, password.iv);
-            }),
-            catchError((err) => route_error(http.getRequest(), err)),
+  public constructor(
+    private readonly method: string,
+    private readonly stringify: (input: any) => 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)
+          throw NoTransformConfigureError(`EncryptedRoute.${this.method}`);
+
+        const headers: Singleton<Record<string, string>> = new Singleton(() => {
+          const request: express.Request = http.getRequest();
+          return headers_to_object(request.headers);
+        });
+        const body: string | undefined = this.stringify(value);
+        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,
+  Get,
+  Post,
+  Put,
+  Patch,
+  Delete,
 };

package/src/decorators/PlainBody.ts

@@ -1,75 +1,72 @@
-import {
-    BadRequestException,
-    ExecutionContext,
-    createParamDecorator,
-} from "@nestjs/common";
-import type express from "express";
-import type { FastifyRequest } from "fastify";
-
-import { assert } from "typia";
-
-import { get_text_body } from "./internal/get_text_body";
-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 (!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;
-    })();
-}
-Object.assign(PlainBody, assert);
-
-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 { assert } from "typia";
+
+import { get_text_body } from "./internal/get_text_body";
+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 (!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;
+  })();
+}
+Object.assign(PlainBody, assert);
+
+const isTextPlain = (text?: string): boolean =>
+  text !== undefined &&
+  text
+    .split(";")
+    .map((str) => str.trim())
+    .some((str) => str === "text/plain");

package/src/decorators/TypedBody.ts

@@ -1,60 +1,59 @@
-import {
-    BadRequestException,
-    ExecutionContext,
-    createParamDecorator,
-} from "@nestjs/common";
-import type express from "express";
-import type { FastifyRequest } from "fastify";
-
-import { assert, is, misc, validate } from "typia";
-
-import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
-import { validate_request_body } from "./internal/validate_request_body";
-
-/**
- * Type safe body decorator.
- *
- * `TypedBody` is a decorator function getting `application/json` typed data from
- * request body. Also, it validates the request body data type through
- * [typia](https://github.com/samchon/typia) and the validation speed is
- * maximum 20,000x times faster than `class-validator`.
- *
- * For reference, when the request body data is not following the promised type `T`,
- * `BadRequestException` error (status code: 400) would be thrown.
- *
- * @param validator Custom validator if required. Default is `typia.assert()`
- * @author Jeongho Nam - https://github.com/samchon
- */
-export function TypedBody<T>(
-    validator?: IRequestBodyValidator<T>,
-): ParameterDecorator {
-    const checker = validate_request_body("TypedBody")(validator);
-    return createParamDecorator(function TypedBody(
-        _unknown: any,
-        context: ExecutionContext,
-    ) {
-        const request: express.Request | FastifyRequest = context
-            .switchToHttp()
-            .getRequest();
-        if (isApplicationJson(request.headers["content-type"]) === false)
-            throw new BadRequestException(
-                `Request body type is not "application/json".`,
-            );
-
-        const error: Error | null = checker(request.body);
-        if (error !== null) throw error;
-        return request.body;
-    })();
-}
-
-Object.assign(TypedBody, misc.clone);
-Object.assign(TypedBody, is);
-Object.assign(TypedBody, assert);
-Object.assign(TypedBody, validate);
-
-const isApplicationJson = (text?: string): boolean =>
-    text !== undefined &&
-    text
-        .split(";")
-        .map((str) => str.trim())
-        .some((str) => str === "application/json");
+import {
+  BadRequestException,
+  ExecutionContext,
+  createParamDecorator,
+} from "@nestjs/common";
+import type express from "express";
+import type { FastifyRequest } from "fastify";
+import { assert, is, misc, validate } from "typia";
+
+import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
+import { validate_request_body } from "./internal/validate_request_body";
+
+/**
+ * Type safe body decorator.
+ *
+ * `TypedBody` is a decorator function getting `application/json` typed data from
+ * request body. Also, it validates the request body data type through
+ * [typia](https://github.com/samchon/typia) and the validation speed is
+ * maximum 20,000x times faster than `class-validator`.
+ *
+ * For reference, when the request body data is not following the promised type `T`,
+ * `BadRequestException` error (status code: 400) would be thrown.
+ *
+ * @param validator Custom validator if required. Default is `typia.assert()`
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function TypedBody<T>(
+  validator?: IRequestBodyValidator<T>,
+): ParameterDecorator {
+  const checker = validate_request_body("TypedBody")(validator);
+  return createParamDecorator(function TypedBody(
+    _unknown: any,
+    context: ExecutionContext,
+  ) {
+    const request: express.Request | FastifyRequest = context
+      .switchToHttp()
+      .getRequest();
+    if (isApplicationJson(request.headers["content-type"]) === false)
+      throw new BadRequestException(
+        `Request body type is not "application/json".`,
+      );
+
+    const error: Error | null = checker(request.body);
+    if (error !== null) throw error;
+    return request.body;
+  })();
+}
+
+Object.assign(TypedBody, misc.clone);
+Object.assign(TypedBody, is);
+Object.assign(TypedBody, assert);
+Object.assign(TypedBody, validate);
+
+const isApplicationJson = (text?: string): boolean =>
+  text !== undefined &&
+  text
+    .split(";")
+    .map((str) => str.trim())
+    .some((str) => str === "application/json");