@nestia/core 0.1.4 → 0.1.5

package/src/decorators/EncryptedBody.ts

@@ -1,102 +1,102 @@
-import { AesPkcs5, IEncryptionPassword } from "@nestia/fetcher";
-import {
-    BadRequestException,
-    ExecutionContext,
-    createParamDecorator,
-} from "@nestjs/common";
-import type express from "express";
-import raw from "raw-body";
-import { assert, is, validate } from "typia";
-
-import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
-import { Singleton } from "../utils/Singleton";
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
-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 JSON data from HTTP request who've
- * been encrypted by AES-128/256 algorithm. Also, `EncyrptedBody` validates the JSON
- * data type through
- * [`typia.assert()`](https://github.com/samchon/typia#runtime-type-checkers)
- * function and throws `BadRequestException` error (status code: 400), if the JSON
- * data is not following the promised type.
- *
- * For reference, `EncryptedRoute` decrypts request body usnig those options.
- *
- *  - AES-128/256
- *  - CBC mode
- *  - PKCS #5 Padding
- *  - Base64 Encoding
- *
- * @return Parameter decorator
- * @author Jeongho Nam - https://github.com/samchon
- */
-export function EncryptedBody<T>(validator?: IRequestBodyValidator<T>) {
-    const checker = validate_request_body("EncryptedBody")(validator);
-    return createParamDecorator(async function EncryptedBody(
-        _unknown: any,
-        ctx: ExecutionContext,
-    ) {
-        const request: express.Request = ctx.switchToHttp().getRequest();
-        if (request.readable === false)
-            throw new BadRequestException(
-                "Request body is not the text/plain.",
-            );
-
-        const param:
-            | IEncryptionPassword
-            | IEncryptionPassword.Closure
-            | undefined = Reflect.getMetadata(
-            ENCRYPTION_METADATA_KEY,
-            ctx.getClass(),
-        );
-        if (!param)
-            throw new Error(
-                "Error on 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 raw(request, "utf8")).trim();
-        const password: IEncryptionPassword =
-            typeof param === "function"
-                ? param({ headers: headers.get(), body }, false)
-                : param;
-        const disabled: boolean =
-            password.disabled === undefined
-                ? false
-                : typeof password.disabled === "function"
-                ? password.disabled({ headers: headers.get(), body }, true)
-                : password.disabled;
-
-        // PARSE AND VALIDATE DATA
-        const data: any = JSON.parse(
-            disabled ? body : decrypt(body, password.key, password.iv),
-        );
-        checker(data);
-        return data;
-    })();
-}
-Object.assign(EncryptedBody, assert);
-Object.assign(EncryptedBody, is);
-Object.assign(EncryptedBody, validate);
-
-/**
- * @internal
- */
-function 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;
-    }
-}
+import { AesPkcs5, IEncryptionPassword } from "@nestia/fetcher";
+import {
+    BadRequestException,
+    ExecutionContext,
+    createParamDecorator,
+} from "@nestjs/common";
+import type express from "express";
+import raw from "raw-body";
+import { assert, is, validate } from "typia";
+
+import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
+import { Singleton } from "../utils/Singleton";
+import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+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 JSON data from HTTP request who've
+ * been encrypted by AES-128/256 algorithm. Also, `EncyrptedBody` validates the JSON
+ * data type through
+ * [`typia.assert()`](https://github.com/samchon/typia#runtime-type-checkers)
+ * function and throws `BadRequestException` error (status code: 400), if the JSON
+ * data is not following the promised type.
+ *
+ * For reference, `EncryptedRoute` decrypts request body usnig those options.
+ *
+ *  - AES-128/256
+ *  - CBC mode
+ *  - PKCS #5 Padding
+ *  - Base64 Encoding
+ *
+ * @return Parameter decorator
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function EncryptedBody<T>(validator?: IRequestBodyValidator<T>) {
+    const checker = validate_request_body("EncryptedBody")(validator);
+    return createParamDecorator(async function EncryptedBody(
+        _unknown: any,
+        ctx: ExecutionContext,
+    ) {
+        const request: express.Request = ctx.switchToHttp().getRequest();
+        if (request.readable === false)
+            throw new BadRequestException(
+                "Request body is not the text/plain.",
+            );
+
+        const param:
+            | IEncryptionPassword
+            | IEncryptionPassword.Closure
+            | undefined = Reflect.getMetadata(
+            ENCRYPTION_METADATA_KEY,
+            ctx.getClass(),
+        );
+        if (!param)
+            throw new Error(
+                "Error on 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 raw(request, "utf8")).trim();
+        const password: IEncryptionPassword =
+            typeof param === "function"
+                ? param({ headers: headers.get(), body }, false)
+                : param;
+        const disabled: boolean =
+            password.disabled === undefined
+                ? false
+                : typeof password.disabled === "function"
+                ? password.disabled({ headers: headers.get(), body }, true)
+                : password.disabled;
+
+        // PARSE AND VALIDATE DATA
+        const data: any = JSON.parse(
+            disabled ? body : decrypt(body, password.key, password.iv),
+        );
+        checker(data);
+        return data;
+    })();
+}
+Object.assign(EncryptedBody, assert);
+Object.assign(EncryptedBody, is);
+Object.assign(EncryptedBody, validate);
+
+/**
+ * @internal
+ */
+function 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;
+    }
+}

package/src/decorators/EncryptedController.ts

@@ -1,43 +1,43 @@
-import { IEncryptionPassword } from "@nestia/fetcher";
-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.
- *
- * > However, if you've configure the {@link IEncryptionPassword.disabled} to be `true`,
- * > you can disable the encryption and decryption algorithm. Therefore, when the
- * > {@link IEncryptionPassword.disable} becomes the `true`, content like request and
- * > response body would be considered as a plain text instead.
- *
- * 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";
+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.
+ *
+ * > However, if you've configure the {@link IEncryptionPassword.disabled} to be `true`,
+ * > you can disable the encryption and decryption algorithm. Therefore, when the
+ * > {@link IEncryptionPassword.disable} becomes the `true`, content like request and
+ * > response body would be considered as a plain text instead.
+ *
+ * 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,127 +1,77 @@
-import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
-import { Module, ModuleMetadata } from "@nestjs/common";
-import is_ts_node from "detect-ts-node";
-import fs from "fs";
-
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
-
-/**
- * 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: ModuleMetadata,
-    password: IEncryptionPassword | IEncryptionPassword.Closure,
-): ClassDecorator {
-    return function (target: any) {
-        Module(metadata)(target);
-        if (metadata.controllers === undefined) return;
-
-        for (const controller of metadata.controllers)
-            if (
-                Reflect.hasMetadata(ENCRYPTION_METADATA_KEY, controller) ===
-                false
-            )
-                Reflect.defineMetadata(
-                    ENCRYPTION_METADATA_KEY,
-                    password,
-                    controller,
-                );
-    };
-}
-
-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
-     * @returns Class decorated module instance
-     */
-    export async function dynamic(
-        path: string,
-        password: IEncryptionPassword | IEncryptionPassword.Closure,
-    ): Promise<object> {
-        // LOAD CONTROLLERS
-        const metadata: ModuleMetadata = {
-            controllers: await controllers(path, password),
-        };
-
-        // RETURNS WITH DECORATING
-        @EncryptedModule(metadata, password)
-        class Module {}
-        return Module;
-    }
-
-    async function controllers(
-        path: string,
-        password: IEncryptionPassword | IEncryptionPassword.Closure,
-    ): Promise<any[]> {
-        const output: any[] = [];
-        await iterate(output, path);
-
-        for (const controller of output)
-            if (
-                Reflect.hasMetadata(ENCRYPTION_METADATA_KEY, controller) ===
-                false
-            )
-                Reflect.defineMetadata(
-                    ENCRYPTION_METADATA_KEY,
-                    password,
-                    controller,
-                );
-
-        return output;
-    }
-
-    async function iterate(controllers: object[], path: string): Promise<void> {
-        const directory: string[] = await fs.promises.readdir(path);
-        for (const file of directory) {
-            const current: string = `${path}/${file}`;
-            const stats: fs.Stats = await fs.promises.lstat(current);
-
-            if (stats.isDirectory() === true)
-                await iterate(controllers, current);
-            else if (file.substring(file.length - 3) === `.${EXTENSION}`) {
-                const external: any = await import(current);
-                for (const key in external) {
-                    const instance: object = external[key];
-                    if (Reflect.getMetadata("path", instance) !== undefined)
-                        controllers.push(instance);
-                }
-            }
-        }
-    }
-}
-const EXTENSION = is_ts_node ? "ts" : "js";
+import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
+import { Module, ModuleMetadata } 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: ModuleMetadata,
+    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
+     * @returns Class decorated module instance
+     */
+    export async function dynamic(
+        path: string,
+        password: IEncryptionPassword | IEncryptionPassword.Closure,
+    ): Promise<object> {
+        // LOAD CONTROLLERS
+        const controllers: Creator<object>[] = await load_controllers(path);
+
+        // RETURNS WITH DECORATING
+        @EncryptedModule({ controllers }, password)
+        class NestiaModule {}
+        return NestiaModule;
+    }
+}