@nestia/core 8.0.8 → 9.0.0-dev.20251107

package/src/decorators/DynamicModule.ts

@@ -1,44 +1,44 @@
-import { Module } from "@nestjs/common";
-import { ModuleMetadata } from "@nestjs/common/interfaces";
-
-import { Creator } from "../typings/Creator";
-import { load_controllers } from "./internal/load_controller";
-
-/**
- * Dynamic module.
- *
- * `DynamicModule` is a namespace wrapping a convenient function, which can load
- * controller classes dynamically just by specifying their directory path.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace DynamicModule {
-  /**
-   * Mount dynamic module.
-   *
-   * Constructs a module instance with directory path of controller classes.
-   *
-   * Every controller classes in the target directory would be dynamically
-   * mounted.
-   *
-   * @param path Path of controllers
-   * @param metadata Additional metadata except controllers
-   * @returns Module instance
-   */
-  export async function mount(
-    path: string | string[] | { include: string[]; exclude?: string[] },
-    metadata: Omit<ModuleMetadata, "controllers"> = {},
-    isTsNode?: boolean,
-  ) {
-    // LOAD CONTROLLERS
-    const controllers: Creator<object>[] = await load_controllers(
-      path,
-      isTsNode,
-    );
-
-    // RETURN WITH DECORATING
-    @Module({ ...metadata, controllers })
-    class NestiaModule {}
-    return NestiaModule;
-  }
-}
+import { Module } from "@nestjs/common";
+import { ModuleMetadata } from "@nestjs/common/interfaces";
+
+import { Creator } from "../typings/Creator";
+import { load_controllers } from "./internal/load_controller";
+
+/**
+ * Dynamic module.
+ *
+ * `DynamicModule` is a namespace wrapping a convenient function, which can load
+ * controller classes dynamically just by specifying their directory path.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace DynamicModule {
+  /**
+   * Mount dynamic module.
+   *
+   * Constructs a module instance with directory path of controller classes.
+   *
+   * Every controller classes in the target directory would be dynamically
+   * mounted.
+   *
+   * @param path Path of controllers
+   * @param metadata Additional metadata except controllers
+   * @returns Module instance
+   */
+  export async function mount(
+    path: string | string[] | { include: string[]; exclude?: string[] },
+    metadata: Omit<ModuleMetadata, "controllers"> = {},
+    isTsNode?: boolean,
+  ) {
+    // LOAD CONTROLLERS
+    const controllers: Creator<object>[] = await load_controllers(
+      path,
+      isTsNode,
+    );
+
+    // RETURN WITH DECORATING
+    @Module({ ...metadata, controllers })
+    class NestiaModule {}
+    return NestiaModule;
+  }
+}

package/src/decorators/EncryptedBody.ts

@@ -1,97 +1,97 @@
-import { AesPkcs5 } from "@nestia/fetcher/lib/AesPkcs5";
-import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
-import {
-  BadRequestException,
-  ExecutionContext,
-  createParamDecorator,
-} from "@nestjs/common";
-import type express from "express";
-import type { FastifyRequest } from "fastify";
-
-import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
-import { Singleton } from "../utils/Singleton";
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
-import { get_text_body } from "./internal/get_text_body";
-import { headers_to_object } from "./internal/headers_to_object";
-import { validate_request_body } from "./internal/validate_request_body";
-
-/**
- * Encrypted body decorator.
- *
- * `EncryptedBody` is a decorator function getting `application/json` typed data
- * from request body which has been encrypted by AES-128/256 algorithm. Also,
- * `EncryptedBody` validates the request body data type through
- * [typia](https://github.com/samchon/typia) ad the validation speed is maximum
- * 15,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. Also,
- * `EncryptedRoute` decrypts request body using those options.
- *
- * - AES-128/256
- * - CBC mode
- * - PKCS #5 Padding
- * - Base64 Encoding
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @returns Parameter decorator
- */
-export function EncryptedBody<T>(
-  validator?: IRequestBodyValidator<T>,
-): ParameterDecorator {
-  const checker = validate_request_body("EncryptedBody")(validator);
-  return createParamDecorator(async function EncryptedBody(
-    _unknown: any,
-    context: ExecutionContext,
-  ) {
-    const request: express.Request | FastifyRequest = context
-      .switchToHttp()
-      .getRequest();
-    if (isTextPlain(request.headers["content-type"]) === false)
-      throw new BadRequestException(`Request body type is not "text/plain".`);
-
-    const param: IEncryptionPassword | IEncryptionPassword.Closure | undefined =
-      Reflect.getMetadata(ENCRYPTION_METADATA_KEY, context.getClass());
-    if (!param)
-      throw new Error(
-        "Error on nestia.core.EncryptedBody(): no encryption password is given.",
-      );
-
-    // GET BODY DATA
-    const headers: Singleton<Record<string, string>> = new Singleton(() =>
-      headers_to_object(request.headers),
-    );
-    const body: string = await get_text_body(request);
-    const password: IEncryptionPassword =
-      typeof param === "function"
-        ? param({ headers: headers.get(), body, direction: "decode" })
-        : param;
-
-    // PARSE AND VALIDATE DATA
-    const data: any = JSON.parse(decrypt(body, password.key, password.iv));
-    const error: Error | null = checker(data);
-    if (error !== null) throw error;
-    return data;
-  })();
-}
-
-/** @internal */
-const decrypt = (body: string, key: string, iv: string): string => {
-  try {
-    return AesPkcs5.decrypt(body, key, iv);
-  } catch (exp) {
-    if (exp instanceof Error)
-      throw new BadRequestException(
-        "Failed to decrypt the request body. Check your body content or encryption password.",
-      );
-    else throw exp;
-  }
-};
-
-/** @internal */
-const isTextPlain = (text?: string): boolean =>
-  text !== undefined &&
-  text
-    .split(";")
-    .map((str) => str.trim())
-    .some((str) => str === "text/plain");
+import { AesPkcs5 } from "@nestia/fetcher/lib/AesPkcs5";
+import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
+import {
+  BadRequestException,
+  ExecutionContext,
+  createParamDecorator,
+} from "@nestjs/common";
+import type express from "express";
+import type { FastifyRequest } from "fastify";
+
+import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
+import { Singleton } from "../utils/Singleton";
+import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+import { get_text_body } from "./internal/get_text_body";
+import { headers_to_object } from "./internal/headers_to_object";
+import { validate_request_body } from "./internal/validate_request_body";
+
+/**
+ * Encrypted body decorator.
+ *
+ * `EncryptedBody` is a decorator function getting `application/json` typed data
+ * from request body which has been encrypted by AES-128/256 algorithm. Also,
+ * `EncryptedBody` validates the request body data type through
+ * [typia](https://github.com/samchon/typia) ad the validation speed is maximum
+ * 15,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. Also,
+ * `EncryptedRoute` decrypts request body using those options.
+ *
+ * - AES-128/256
+ * - CBC mode
+ * - PKCS #5 Padding
+ * - Base64 Encoding
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns Parameter decorator
+ */
+export function EncryptedBody<T>(
+  validator?: IRequestBodyValidator<T>,
+): ParameterDecorator {
+  const checker = validate_request_body("EncryptedBody")(validator);
+  return createParamDecorator(async function EncryptedBody(
+    _unknown: any,
+    context: ExecutionContext,
+  ) {
+    const request: express.Request | FastifyRequest = context
+      .switchToHttp()
+      .getRequest();
+    if (isTextPlain(request.headers["content-type"]) === false)
+      throw new BadRequestException(`Request body type is not "text/plain".`);
+
+    const param: IEncryptionPassword | IEncryptionPassword.Closure | undefined =
+      Reflect.getMetadata(ENCRYPTION_METADATA_KEY, context.getClass());
+    if (!param)
+      throw new Error(
+        "Error on nestia.core.EncryptedBody(): no encryption password is given.",
+      );
+
+    // GET BODY DATA
+    const headers: Singleton<Record<string, string>> = new Singleton(() =>
+      headers_to_object(request.headers),
+    );
+    const body: string = await get_text_body(request);
+    const password: IEncryptionPassword =
+      typeof param === "function"
+        ? param({ headers: headers.get(), body, direction: "decode" })
+        : param;
+
+    // PARSE AND VALIDATE DATA
+    const data: any = JSON.parse(decrypt(body, password.key, password.iv));
+    const error: Error | null = checker(data);
+    if (error !== null) throw error;
+    return data;
+  })();
+}
+
+/** @internal */
+const decrypt = (body: string, key: string, iv: string): string => {
+  try {
+    return AesPkcs5.decrypt(body, key, iv);
+  } catch (exp) {
+    if (exp instanceof Error)
+      throw new BadRequestException(
+        "Failed to decrypt the request body. Check your body content or encryption password.",
+      );
+    else throw exp;
+  }
+};
+
+/** @internal */
+const isTextPlain = (text?: string): boolean =>
+  text !== undefined &&
+  text
+    .split(";")
+    .map((str) => str.trim())
+    .some((str) => str === "text/plain");

package/src/decorators/EncryptedController.ts

@@ -1,40 +1,40 @@
-import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
-import { Controller } from "@nestjs/common";
-
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
-
-/**
- * Encrypted controller.
- *
- * `EncryptedController` is an extension of the {@link nest.Controller} 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 body of the HTTP protocol.
- *
- * By the way, you can configure the encryption password in the global level by
- * using {@link EncryptedModule} instead of the {@link nest.Module} in the module
- * level. In that case, you don't need to use this `EncryptedController` more.
- * Just use the {@link nest.Controller} without duplicated encryption password
- * definitions.
- *
- * Of course, if you want to use different encryption password from the
- * {@link EncryptedModule}, this `EncryptedController` would be useful again.
- * Therefore, I recommend to use this `EncryptedController` decorator function
- * only when you must configure different encryption password from the
- * {@link EncryptedModule}.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param path Path of the HTTP request
- * @param password Encryption password or its getter function
- * @returns Class decorator
- */
-export function EncryptedController(
-  path: string,
-  password: IEncryptionPassword | IEncryptionPassword.Closure,
-): ClassDecorator {
-  return function (target: any) {
-    Reflect.defineMetadata(ENCRYPTION_METADATA_KEY, password, target);
-    Controller(path)(target);
-  };
-}
+import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
+import { Controller } from "@nestjs/common";
+
+import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+
+/**
+ * Encrypted controller.
+ *
+ * `EncryptedController` is an extension of the {@link nest.Controller} 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 body of the HTTP protocol.
+ *
+ * By the way, you can configure the encryption password in the global level by
+ * using {@link EncryptedModule} instead of the {@link nest.Module} in the module
+ * level. In that case, you don't need to use this `EncryptedController` more.
+ * Just use the {@link nest.Controller} without duplicated encryption password
+ * definitions.
+ *
+ * Of course, if you want to use different encryption password from the
+ * {@link EncryptedModule}, this `EncryptedController` would be useful again.
+ * Therefore, I recommend to use this `EncryptedController` decorator function
+ * only when you must configure different encryption password from the
+ * {@link EncryptedModule}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param path Path of the HTTP request
+ * @param password Encryption password or its getter function
+ * @returns Class decorator
+ */
+export function EncryptedController(
+  path: string,
+  password: IEncryptionPassword | IEncryptionPassword.Closure,
+): ClassDecorator {
+  return function (target: any) {
+    Reflect.defineMetadata(ENCRYPTION_METADATA_KEY, password, target);
+    Controller(path)(target);
+  };
+}

package/src/decorators/EncryptedModule.ts

@@ -1,98 +1,98 @@
-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.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param metadata Module configuration metadata
- * @param password Encryption password or its getter function
- * @returns Class decorator
- */
-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"> = {},
-    isTsNode?: boolean,
-  ) {
-    // LOAD CONTROLLERS
-    const controllers: Creator<object>[] = await load_controllers(
-      path,
-      isTsNode,
-    );
-
-    // 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);
-  };
+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.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param metadata Module configuration metadata
+ * @param password Encryption password or its getter function
+ * @returns Class decorator
+ */
+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"> = {},
+    isTsNode?: boolean,
+  ) {
+    // LOAD CONTROLLERS
+    const controllers: Creator<object>[] = await load_controllers(
+      path,
+      isTsNode,
+    );
+
+    // 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);
+  };