@nestia/core 0.1.5 → 0.1.7

package/src/decorators/EncryptedModule.ts

@@ -1,77 +1,77 @@
-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;
-    }
-}
+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;
+    }
+}

package/src/decorators/EncryptedRoute.ts

@@ -1,203 +1,203 @@
-import { AesPkcs5, IEncryptionPassword } from "@nestia/fetcher";
-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 { Observable, catchError, map } from "rxjs";
-import {
-    assertStringify,
-    isStringify,
-    stringify,
-    validateStringify,
-} from "typia";
-
-import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
-import { Singleton } from "../utils/Singleton";
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
-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/250 encryption. Also, those decorator functions
- * can boost up JSON string conversion speed about 5x times faster, through
- * [`typia.stringify()`](https://github.com/samchon/typia#fastest-json-string-conversion).
- *
- * For reference, `EncryptedRoute` encrypts response body usnig those options.
- *
- *  - AES-128/256
- *  - CBC mode
- *  - PKCS #5 Padding
- *  - Base64 Encoding
- *
- * Also, router functions in `EncryptedRoute` can convert custom error classes to the
- * regular {@link nest.HttpException} class automatically, through
- * {@link ExceptionManager}.
- *
- * @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>,
-        ): MethodDecorator;
-        function route<T>(
-            path: string | string[],
-            stringify?: IResponseBodyStringifier<T>,
-        ): 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 [
-    assertStringify,
-    isStringify,
-    stringify,
-    validateStringify,
-]) {
-    Object.assign(EncryptedRoute.Get, method);
-    Object.assign(EncryptedRoute.Delete, method);
-    Object.assign(EncryptedRoute.Post, method);
-    Object.assign(EncryptedRoute.Put, method);
-    Object.assign(EncryptedRoute.Patch, method);
-}
-
-/**
- * @internal
- */
-class EncryptedRouteInterceptor implements NestInterceptor {
-    public constructor(
-        private readonly method: string,
-        private readonly stringify: (input: any) => string,
-    ) {}
-
-    public intercept(
-        context: ExecutionContext,
-        next: CallHandler,
-    ): Observable<any> {
-        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 new Error(
-                        `Error on EncryptedRoute.${this.method}(): no encryption password is given.`,
-                    );
-
-                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 }, false)
-                        : param;
-                const disabled: boolean =
-                    password.disabled === undefined
-                        ? false
-                        : typeof password.disabled === "function"
-                        ? password.disabled(
-                              { headers: headers.get(), body },
-                              false,
-                          )
-                        : password.disabled;
-
-                const response: express.Response = http.getResponse();
-                response.header(
-                    "Content-Type",
-                    disabled ? "application/json" : "text/plain",
-                );
-
-                if (disabled === true) return body;
-                else 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,
-};
+import { AesPkcs5, IEncryptionPassword } from "@nestia/fetcher";
+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 { Observable, catchError, map } from "rxjs";
+import {
+    assertStringify,
+    isStringify,
+    stringify,
+    validateStringify,
+} from "typia";
+
+import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
+import { Singleton } from "../utils/Singleton";
+import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+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/250 encryption. Also, those decorator functions
+ * can boost up JSON string conversion speed about 5x times faster, through
+ * [`typia.stringify()`](https://github.com/samchon/typia#fastest-json-string-conversion).
+ *
+ * For reference, `EncryptedRoute` encrypts response body usnig those options.
+ *
+ *  - AES-128/256
+ *  - CBC mode
+ *  - PKCS #5 Padding
+ *  - Base64 Encoding
+ *
+ * Also, router functions in `EncryptedRoute` can convert custom error classes to the
+ * regular {@link nest.HttpException} class automatically, through
+ * {@link ExceptionManager}.
+ *
+ * @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>,
+        ): MethodDecorator;
+        function route<T>(
+            path: string | string[],
+            stringify?: IResponseBodyStringifier<T>,
+        ): 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 [
+    assertStringify,
+    isStringify,
+    stringify,
+    validateStringify,
+]) {
+    Object.assign(EncryptedRoute.Get, method);
+    Object.assign(EncryptedRoute.Delete, method);
+    Object.assign(EncryptedRoute.Post, method);
+    Object.assign(EncryptedRoute.Put, method);
+    Object.assign(EncryptedRoute.Patch, method);
+}
+
+/**
+ * @internal
+ */
+class EncryptedRouteInterceptor implements NestInterceptor {
+    public constructor(
+        private readonly method: string,
+        private readonly stringify: (input: any) => string,
+    ) {}
+
+    public intercept(
+        context: ExecutionContext,
+        next: CallHandler,
+    ): Observable<any> {
+        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 new Error(
+                        `Error on EncryptedRoute.${this.method}(): no encryption password is given.`,
+                    );
+
+                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 }, false)
+                        : param;
+                const disabled: boolean =
+                    password.disabled === undefined
+                        ? false
+                        : typeof password.disabled === "function"
+                        ? password.disabled(
+                              { headers: headers.get(), body },
+                              false,
+                          )
+                        : password.disabled;
+
+                const response: express.Response = http.getResponse();
+                response.header(
+                    "Content-Type",
+                    disabled ? "application/json" : "text/plain",
+                );
+
+                if (disabled === true) return body;
+                else 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,
+};

package/src/decorators/PlainBody.ts

@@ -1,38 +1,38 @@
-import {
-    BadRequestException,
-    ExecutionContext,
-    createParamDecorator,
-} from "@nestjs/common";
-import type express from "express";
-import raw from "raw-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-helper` 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 const PlainBody: () => ParameterDecorator = createParamDecorator(
-    async function PlainBody(_data: any, context: ExecutionContext) {
-        const request: express.Request = context.switchToHttp().getRequest();
-        if (!request.readable) throw new BadRequestException("Invalid body");
-
-        const body: string = (await raw(request)).toString("utf8").trim();
-        return body;
-    },
-);
+import {
+    BadRequestException,
+    ExecutionContext,
+    createParamDecorator,
+} from "@nestjs/common";
+import type express from "express";
+import raw from "raw-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 const PlainBody: () => ParameterDecorator = createParamDecorator(
+    async function PlainBody(_data: any, context: ExecutionContext) {
+        const request: express.Request = context.switchToHttp().getRequest();
+        if (!request.readable) throw new BadRequestException("Invalid body");
+
+        const body: string = (await raw(request)).toString("utf8").trim();
+        return body;
+    },
+);