@nestia/core 3.0.0-dev.20231209 → 3.0.0

package/src/decorators/EncryptedModule.ts

@@ -1,79 +1,96 @@
-import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
-import { Module } from "@nestjs/common";
-
-import { Creator } from "../typings/Creator";
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
-import { load_controllers } from "./internal/load_controller";
-
-/**
- * Encrypted module.
- *
- * `EncryptedModule` is an extension of the {@link Module} class decorator function
- * who configures encryption password of the AES-128/256 algorithm. The encryption
- * algorithm and password would be used by {@link EncryptedRoute} and {@link EncryptedBody}
- * to encrypt the request and response bod of the HTTP protocol.
- *
- * By using this `EncryptedModule` decorator function, all of the
- * {@link Controller controllers} configured in the *metadata* would be automatically
- * changed to the {@link EncryptedController} with the *password*. If there're some
- * original {@link EncryptedController} decorated classes in the *metadata*, their
- * encryption password would be kept.
- *
- * Therefore, if you're planning to place original {@link EncryptedController} decorated
- * classes in the *metadata*, I hope them to have different encryption password from the
- * module level. If not, I recommend you use the {@link Controller} decorator
- * function instead.
- *
- * In addition, the `EncryptedModule` supports a convenient dynamic controller importing
- * function, {@link EncryptedModule.dynamic}. If you utilize the function with directory
- * path of the controller classes, it imports and configures the controller classes into
- * the `Module`, automatically.
- *
- * @param metadata Module configuration metadata
- * @param password Encryption password or its getter function
- * @returns Class decorator
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export function EncryptedModule(
-  metadata: Parameters<typeof Module>[0],
-  password: IEncryptionPassword | IEncryptionPassword.Closure,
-): ClassDecorator {
-  return function (target: any) {
-    Module(metadata)(target);
-    if (metadata.controllers === undefined) return;
-
-    for (const c of metadata.controllers)
-      if (Reflect.hasMetadata(ENCRYPTION_METADATA_KEY, c) === false)
-        Reflect.defineMetadata(ENCRYPTION_METADATA_KEY, password, c);
-  };
-}
-
-export namespace EncryptedModule {
-  /**
-   * Dynamic encrypted module.
-   *
-   * `EncryptedModule.dynamic` is an extension of the {@link EncryptedModule} function
-   * who configures controller classes by the dynamic importing. By specifying directory
-   * path of the controller classes, those controllers would be automatically imported
-   * and configured.
-   *
-   * @param path Directory path of the controller classes
-   * @param password Encryption password or its getter function
-   * @param options Additional options except controller
-   * @returns Class decorated module instance
-   */
-  export async function dynamic(
-    path: string | string[] | { include: string[]; exclude?: string[] },
-    password: IEncryptionPassword | IEncryptionPassword.Closure,
-    options: Omit<Parameters<typeof Module>[0], "controllers"> = {},
-  ): Promise<object> {
-    // LOAD CONTROLLERS
-    const controllers: Creator<object>[] = await load_controllers(path);
-
-    // RETURNS WITH DECORATING
-    @EncryptedModule({ ...options, controllers }, password)
-    class NestiaModule {}
-    return NestiaModule;
-  }
-}
+import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
+import { Module } from "@nestjs/common";
+
+import { Creator } from "../typings/Creator";
+import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+import { load_controllers } from "./internal/load_controller";
+
+/**
+ * Encrypted module.
+ *
+ * `EncryptedModule` is an extension of the {@link Module} class decorator function
+ * who configures encryption password of the AES-128/256 algorithm. The encryption
+ * algorithm and password would be used by {@link EncryptedRoute} and {@link EncryptedBody}
+ * to encrypt the request and response bod of the HTTP protocol.
+ *
+ * By using this `EncryptedModule` decorator function, all of the
+ * {@link Controller controllers} configured in the *metadata* would be automatically
+ * changed to the {@link EncryptedController} with the *password*. If there're some
+ * original {@link EncryptedController} decorated classes in the *metadata*, their
+ * encryption password would be kept.
+ *
+ * Therefore, if you're planning to place original {@link EncryptedController} decorated
+ * classes in the *metadata*, I hope them to have different encryption password from the
+ * module level. If not, I recommend you use the {@link Controller} decorator
+ * function instead.
+ *
+ * In addition, the `EncryptedModule` supports a convenient dynamic controller importing
+ * function, {@link EncryptedModule.dynamic}. If you utilize the function with directory
+ * path of the controller classes, it imports and configures the controller classes into
+ * the `Module`, automatically.
+ *
+ * @param metadata Module configuration metadata
+ * @param password Encryption password or its getter function
+ * @returns Class decorator
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function EncryptedModule(
+  metadata: Parameters<typeof Module>[0],
+  password: IEncryptionPassword.Closure,
+): ClassDecorator {
+  return function (target: any) {
+    Module(metadata)(target);
+    iterate(password)(target);
+  };
+}
+
+export namespace EncryptedModule {
+  /**
+   * Dynamic encrypted module.
+   *
+   * `EncryptedModule.dynamic` is an extension of the {@link EncryptedModule} function
+   * who configures controller classes by the dynamic importing. By specifying directory
+   * path of the controller classes, those controllers would be automatically imported
+   * and configured.
+   *
+   * @param path Directory path of the controller classes
+   * @param password Encryption password or its getter function
+   * @param options Additional options except controller
+   * @returns Class decorated module instance
+   */
+  export async function dynamic(
+    path: string | string[] | { include: string[]; exclude?: string[] },
+    password: IEncryptionPassword | IEncryptionPassword.Closure,
+    options: Omit<Parameters<typeof Module>[0], "controllers"> = {},
+  ): Promise<object> {
+    // LOAD CONTROLLERS
+    const controllers: Creator<object>[] = await load_controllers(path);
+
+    // RETURNS WITH DECORATING
+    @EncryptedModule(
+      { ...options, controllers },
+      typeof password === "object" ? () => password : password,
+    )
+    class NestiaModule {}
+    return NestiaModule;
+  }
+}
+
+/**
+ * @internal
+ */
+const iterate =
+  (password: IEncryptionPassword.Closure) =>
+  (modulo: any): void => {
+    const imports = Reflect.getMetadata("imports", modulo);
+    if (Array.isArray(imports))
+      for (const imp of imports)
+        if (typeof imp === "function") iterate(password)(imp);
+
+    const controllers = Reflect.getMetadata("controllers", modulo);
+    if (Array.isArray(controllers))
+      for (const c of controllers)
+        if (typeof c === "function")
+          Reflect.defineMetadata(ENCRYPTION_METADATA_KEY, password, c);
+  };

package/src/decorators/EncryptedRoute.ts

@@ -1,206 +1,182 @@
-import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
-import { AesPkcs5 } from "@nestia/fetcher/lib/internal/AesPkcs5";
-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 type { FastifyRequest } from "fastify";
-import { catchError, map } from "rxjs/operators";
-import typia from "typia";
-
-import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
-import { Singleton } from "../utils/Singleton";
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
-import { NoTransformConfigureError } from "./internal/NoTransformConfigureError";
-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");
-
-  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,
-])
-  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 {
-  private readonly success: number;
-
-  public constructor(
-    private readonly method: string,
-    private readonly stringify: (input: any) => string,
-  ) {
-    this.success =
-      this.method === "GET" || this.method === "DELETE" ? 200 : 201;
-  }
-
-  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: Uint8Array = (() => {
-          const body = this.stringify(value);
-          if (body === undefined) return Buffer.from([]);
-
-          const password: IEncryptionPassword =
-            typeof param === "function"
-              ? param({
-                  body,
-                  direction: "encode",
-                  headers: headers.get(),
-                })
-              : param;
-          return AesPkcs5.encrypt(body, password.key, password.iv);
-        })();
-        // return body;
-        const response: express.Response = http.getResponse();
-        if (isExpressRequest(http.getRequest()))
-          response
-            .header("Content-Type", "application/octet-stream")
-            .status(this.success)
-            .send(body)
-            .end();
-        return body;
-      }),
-      catchError((err) => route_error(http.getRequest(), err)),
-    );
-  }
-}
-
-/**
- * @internal
- */
-const ROUTERS = {
-  Get,
-  Post,
-  Put,
-  Patch,
-  Delete,
-};
-
-/**
- * @internal
- */
-const isExpressRequest = (
-  request: express.Request | FastifyRequest,
-): request is express.Request => (request as express.Request).app !== undefined;
+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 { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+import { NoTransformConfigureError } from "./internal/NoTransformConfigureError";
+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");
+
+  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,
+])
+  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;
+
+        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,
+};