@nestia/core 0.1.0

package/lib/utils/ExceptionManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExceptionManager.js","sourceRoot":"","sources":["../../src/utils/ExceptionManager.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,2CAA4C;AAC5C,yCAA+C;AAC/C,+BAAuC;AAIvC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,IAAiB,gBAAgB,CAsEhC;AAtED,WAAiB,gBAAgB;IAC7B;;;;;;;OAOG;IACH,SAAgB,MAAM,CAClB,OAAmB,EACnB,OAAmB;QAEnB,IAAM,KAAK,GAAW,iBAAA,MAAM,CAAC,SAAS,CAAC,UAAC,KAAK,IAAK,OAAA,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,EAApB,CAAoB,CAAC,CAAC;QACxE,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,iBAAA,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAE1C,iBAAA,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;QAChC,iBAAA,MAAM,CAAC,IAAI,CAAC,UAAC,EAAG,EAAE,EAAG;gBAAR,KAAA,aAAG,EAAF,CAAC,QAAA;gBAAG,KAAA,aAAG,EAAF,CAAC,QAAA;YAAM,OAAA,CAAC,CAAC,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAAnC,CAAmC,CAAC,CAAC;IACnE,CAAC;IATe,uBAAM,SASrB,CAAA;IAED;;;;;OAKG;IACH,SAAgB,KAAK,CAAkB,OAAmB;QACtD,IAAM,KAAK,GAAW,iBAAA,MAAM,CAAC,SAAS,CAAC,UAAC,KAAK,IAAK,OAAA,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,EAApB,CAAoB,CAAC,CAAC;QACxE,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;QAE/B,iBAAA,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACxB,OAAO,IAAI,CAAC;IAChB,CAAC;IANe,sBAAK,QAMpB,CAAA;IAED,SAAgB,EAAE,CAAC,OAA4B;QAC3C,iBAAA,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAFe,mBAAE,KAEjB,CAAA;IAED,SAAgB,GAAG,CAAC,OAA4B;QAC5C,iBAAA,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAFe,oBAAG,MAElB,CAAA;IAqBD;;OAEG;IACU,uBAAM,GAAwC,EAAE,CAAC;IAE9D;;OAEG;IACU,0BAAS,GAA6B,IAAI,GAAG,EAAE,CAAC;AACjE,CAAC,EAtEgB,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAsEhC;AAED,gBAAgB,CAAC,MAAM,CACnB,sBAAc,EACd,UAAC,KAAK;IACF,OAAA,IAAI,sBAAa,CACb;QACI,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,MAAM,EAAE,KAAK,CAAC,OAAO;QACrB,OAAO,EAAE,qDAAqD;KACjE,EACD,GAAG,CACN;AAPD,CAOC,CACR,CAAC;AAEF,gBAAgB,CAAC,MAAM,CACnB,mBAAS,EACT,UAAC,KAAK;IACF,OAAA,IAAI,sBAAa,CACb;QACI,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,OAAO,EAAE,KAAK,CAAC,OAAO;KACzB,EACD,KAAK,CAAC,MAAM,CACf;AAND,CAMC,CACR,CAAC"}

package/lib/utils/Singleton.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/Singleton.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Singleton = void 0;
+/**
+ * @internal
+ */
+var Singleton = /** @class */ (function () {
+    function Singleton(closure_) {
+        this.closure_ = closure_;
+        this.value_ = NOT_MOUNTED_YET;
+    }
+    Singleton.prototype.get = function () {
+        if (this.value_ === NOT_MOUNTED_YET)
+            this.value_ = this.closure_();
+        return this.value_;
+    };
+    return Singleton;
+}());
+exports.Singleton = Singleton;
+/**
+ * @internal
+ */
+var NOT_MOUNTED_YET = {};
+//# sourceMappingURL=Singleton.js.map

package/lib/utils/Singleton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Singleton.js","sourceRoot":"","sources":["../../src/utils/Singleton.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH;IAGI,mBAAoC,QAAiB;QAAjB,aAAQ,GAAR,QAAQ,CAAS;QACjD,IAAI,CAAC,MAAM,GAAG,eAAe,CAAC;IAClC,CAAC;IAEM,uBAAG,GAAV;QACI,IAAI,IAAI,CAAC,MAAM,KAAK,eAAe;YAAE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QACnE,OAAO,IAAI,CAAC,MAAW,CAAC;IAC5B,CAAC;IACL,gBAAC;AAAD,CAAC,AAXD,IAWC;AAXY,8BAAS;AAatB;;GAEG;AACH,IAAM,eAAe,GAAG,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@nestia/core",
+  "version": "0.1.0",
+  "description": "Super-fast validation decorators of NestJS",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "scripts": {
+    "build": "rimraf lib && tsc",
+    "build:test": "rimraf bin && ttsc -p test/tsconfig.json",
+    "dev": "npm run build -- --watch",
+    "eslint": "eslint ./**/*.ts",
+    "eslint:fix": "eslint ./**/*.ts --fix",
+    "prettier": "prettier ./**/*.ts --write",
+    "test": "node bin/test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/samchon/nestia"
+  },
+  "keywords": [
+    "nestjs",
+    "nestia",
+    "typia",
+    "validator",
+    "decorator",
+    "class-validator",
+    "class-transformer"
+  ],
+  "author": "Jeongho Nam",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/samchon/nestia/issues"
+  },
+  "homepage": "https://github.com/samchon/nestia",
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^4.0.0",
+    "@types/express": "^4.17.15",
+    "@typescript-eslint/eslint-plugin": "^5.46.1",
+    "@typescript-eslint/parser": "^5.46.1",
+    "eslint-plugin-deprecation": "^1.3.3",
+    "git-last-commit": "^1.0.1",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.9.1",
+    "tstl": "^2.5.13",
+    "ttypescript": "^1.5.15",
+    "typescript": "^4.9.4"
+  },
+  "dependencies": {
+    "@nestia/fetcher": "^0.1.0",
+    "@nestjs/common": "*",
+    "@nestjs/core": "*",
+    "@nestjs/platform-express": "*",
+    "detect-ts-node": "^1.0.5",
+    "raw-body": "*",
+    "reflect-metadata": "*",
+    "rxjs": "*",
+    "typia": "^3.4.7"
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "package.json",
+    "lib",
+    "src"
+  ]
+}

package/src/decorators/EncryptedBody.ts

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

package/src/decorators/EncryptedController.ts

@@ -0,0 +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);
+    };
+}

package/src/decorators/EncryptedModule.ts

@@ -0,0 +1,127 @@
+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";

package/src/decorators/EncryptedRoute.ts

@@ -0,0 +1,200 @@
+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 { 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(stringify?: (input: any) => string): MethodDecorator;
+        function route(
+            path: string | string[],
+            stringify: (input: any) => string,
+        ): 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

@@ -0,0 +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;
+    },
+);

package/src/decorators/TypedBody.ts

@@ -0,0 +1,49 @@
+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 { validate_request_body } from "./internal/validate_request_body";
+
+/**
+ * Safe body decorator.
+ *
+ * `TypedBody` is a decorator function getting JSON data from HTTP request. Also,
+ * it 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.
+ *
+ * @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(async function TypedBody(
+        _unknown: any,
+        context: ExecutionContext,
+    ) {
+        const request: express.Request = context.switchToHttp().getRequest();
+        if (request.headers["content-type"] !== "application/json") {
+            throw new BadRequestException(
+                "Request body is not the application/json.",
+            );
+        }
+        const data: any = request.body
+            ? request.body
+            : JSON.parse((await raw(request, "utf8")).trim());
+        checker(data);
+        return data;
+    })();
+}
+
+Object.assign(TypedBody, assert);
+Object.assign(TypedBody, is);
+Object.assign(TypedBody, validate);