@nestia/core 2.4.3 → 2.4.4-dev.20240109-3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestia/core",
-  "version": "2.4.3",
+  "version": "2.4.4-dev.20240109-3",
   "description": "Super-fast validation decorators of NestJS",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -38,7 +38,7 @@
   },
   "homepage": "https://nestia.io",
   "dependencies": {
-    "@nestia/fetcher": "^2.4.3",
+    "@nestia/fetcher": "^2.4.4-dev.20240109-3",
     "@nestjs/common": ">=7.0.1",
     "@nestjs/core": ">=7.0.1",
     "@nestjs/platform-express": ">=7.0.1",
@@ -48,10 +48,10 @@
     "raw-body": ">=2.0.0",
     "reflect-metadata": ">=0.1.12",
     "rxjs": ">=6.0.0",
-    "typia": "^5.3.4"
+    "typia": "^5.3.9"
   },
   "peerDependencies": {
-    "@nestia/fetcher": ">=2.4.3",
+    "@nestia/fetcher": ">=2.4.4-dev.20240109-3",
     "@nestjs/common": ">=7.0.1",
     "@nestjs/core": ">=7.0.1",
     "@nestjs/platform-express": ">=7.0.1",
@@ -60,7 +60,7 @@
     "reflect-metadata": ">=0.1.12",
     "rxjs": ">=6.0.0",
     "typescript": ">=4.8.0 <5.4.0",
-    "typia": ">=5.3.4 <6.0.0"
+    "typia": ">=5.3.9 <6.0.0"
   },
   "devDependencies": {
     "@types/express": "^4.17.15",

package/src/decorators/DynamicModule.ts

@@ -1,39 +1,39 @@
-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 Addtional metadata except controllers
-   * @returns module instance
-   */
-  export async function mount(
-    path: string | string[] | { include: string[]; exclude?: string[] },
-    metadata: Omit<ModuleMetadata, "controllers"> = {},
-  ): Promise<object> {
-    // LOAD CONTROLLERS
-    const controllers: Creator<object>[] = await load_controllers(path);
-
-    // 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 Addtional metadata except controllers
+   * @returns module instance
+   */
+  export async function mount(
+    path: string | string[] | { include: string[]; exclude?: string[] },
+    metadata: Omit<ModuleMetadata, "controllers"> = {},
+  ): Promise<object> {
+    // LOAD CONTROLLERS
+    const controllers: Creator<object>[] = await load_controllers(path);
+
+    // RETURN WITH DECORATING
+    @Module({ ...metadata, controllers })
+    class NestiaModule {}
+    return NestiaModule;
+  }
+}

package/src/decorators/EncryptedController.ts

@@ -1,38 +1,38 @@
-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}.
- *
- * @param path Path of the HTTP request
- * @param password Encryption password or its getter function
- * @returns Class decorator
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-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}.
+ *
+ * @param path Path of the HTTP request
+ * @param password Encryption password or its getter function
+ * @returns Class decorator
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+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,79 +1,79 @@
-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 | 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;
+  }
+}

package/src/decorators/PlainBody.ts

@@ -1,72 +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,59 +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");