@nestia/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Jeongho Nam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/decorators/EncryptedBody.d.ts

@@ -0,0 +1,22 @@
+import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
+/**
+ * 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 declare function EncryptedBody<T>(validator: IRequestBodyValidator<T>): ParameterDecorator;

package/lib/decorators/EncryptedBody.js

@@ -0,0 +1,125 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptedBody = void 0;
+var fetcher_1 = require("@nestia/fetcher");
+var common_1 = require("@nestjs/common");
+var raw_body_1 = __importDefault(require("raw-body"));
+var typia_1 = require("typia");
+var Singleton_1 = require("../utils/Singleton");
+var EncryptedConstant_1 = require("./internal/EncryptedConstant");
+var headers_to_object_1 = require("./internal/headers_to_object");
+var validate_request_body_1 = require("./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
+ */
+function EncryptedBody(validator) {
+    var checker = (0, validate_request_body_1.validate_request_body)("EncryptedBody")(validator);
+    return (0, common_1.createParamDecorator)(function EncryptedBody(_unknown, ctx) {
+        return __awaiter(this, void 0, void 0, function () {
+            var request, param, headers, body, password, disabled, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        request = ctx.switchToHttp().getRequest();
+                        if (request.readable === false)
+                            throw new common_1.BadRequestException("Request body is not the text/plain.");
+                        param = Reflect.getMetadata(EncryptedConstant_1.ENCRYPTION_METADATA_KEY, ctx.getClass());
+                        if (!param)
+                            throw new Error("Error on EncryptedBody(): no encryption password is given.");
+                        headers = new Singleton_1.Singleton(function () {
+                            return (0, headers_to_object_1.headers_to_object)(request.headers);
+                        });
+                        return [4 /*yield*/, (0, raw_body_1.default)(request, "utf8")];
+                    case 1:
+                        body = (_a.sent()).trim();
+                        password = typeof param === "function"
+                            ? param({ headers: headers.get(), body: body }, false)
+                            : param;
+                        disabled = password.disabled === undefined
+                            ? false
+                            : typeof password.disabled === "function"
+                                ? password.disabled({ headers: headers.get(), body: body }, true)
+                                : password.disabled;
+                        data = JSON.parse(disabled ? body : decrypt(body, password.key, password.iv));
+                        checker(data);
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    })();
+}
+exports.EncryptedBody = EncryptedBody;
+Object.assign(EncryptedBody, typia_1.assert);
+Object.assign(EncryptedBody, typia_1.is);
+Object.assign(EncryptedBody, typia_1.validate);
+/**
+ * @internal
+ */
+function decrypt(body, key, iv) {
+    try {
+        return fetcher_1.AesPkcs5.decrypt(body, key, iv);
+    }
+    catch (exp) {
+        if (exp instanceof Error)
+            throw new common_1.BadRequestException("Failed to decrypt the request body. Check your body content or encryption password.");
+        else
+            throw exp;
+    }
+}
+//# sourceMappingURL=EncryptedBody.js.map

package/lib/decorators/EncryptedBody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncryptedBody.js","sourceRoot":"","sources":["../../src/decorators/EncryptedBody.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAAgE;AAChE,yCAIwB;AAExB,sDAA2B;AAC3B,+BAA6C;AAG7C,gDAA+C;AAC/C,kEAAuE;AACvE,kEAAiE;AACjE,0EAAyE;AAEzE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,aAAa,CAAI,SAAmC;IAChE,IAAM,OAAO,GAAG,IAAA,6CAAqB,EAAC,eAAe,CAAC,CAAC,SAAS,CAAC,CAAC;IAClE,OAAO,IAAA,6BAAoB,EAAC,SAAe,aAAa,CACpD,QAAa,EACb,GAAqB;;;;;;wBAEf,OAAO,GAAoB,GAAG,CAAC,YAAY,EAAE,CAAC,UAAU,EAAE,CAAC;wBACjE,IAAI,OAAO,CAAC,QAAQ,KAAK,KAAK;4BAC1B,MAAM,IAAI,4BAAmB,CACzB,qCAAqC,CACxC,CAAC;wBAEA,KAAK,GAGO,OAAO,CAAC,WAAW,CACjC,2CAAuB,EACvB,GAAG,CAAC,QAAQ,EAAE,CACjB,CAAC;wBACF,IAAI,CAAC,KAAK;4BACN,MAAM,IAAI,KAAK,CACX,4DAA4D,CAC/D,CAAC;wBAGA,OAAO,GAAsC,IAAI,qBAAS,CAAC;4BAC7D,OAAA,IAAA,qCAAiB,EAAC,OAAO,CAAC,OAAO,CAAC;wBAAlC,CAAkC,CACrC,CAAC;wBACoB,qBAAM,IAAA,kBAAG,EAAC,OAAO,EAAE,MAAM,CAAC,EAAA;;wBAA1C,IAAI,GAAW,CAAC,SAA0B,CAAC,CAAC,IAAI,EAAE;wBAClD,QAAQ,GACV,OAAO,KAAK,KAAK,UAAU;4BACvB,CAAC,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,EAAE,IAAI,MAAA,EAAE,EAAE,KAAK,CAAC;4BAChD,CAAC,CAAC,KAAK,CAAC;wBACV,QAAQ,GACV,QAAQ,CAAC,QAAQ,KAAK,SAAS;4BAC3B,CAAC,CAAC,KAAK;4BACP,CAAC,CAAC,OAAO,QAAQ,CAAC,QAAQ,KAAK,UAAU;gCACzC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,EAAE,IAAI,MAAA,EAAE,EAAE,IAAI,CAAC;gCAC3D,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;wBAGtB,IAAI,GAAQ,IAAI,CAAC,KAAK,CACxB,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC,CAC7D,CAAC;wBACF,OAAO,CAAC,IAAI,CAAC,CAAC;wBACd,sBAAO,IAAI,EAAC;;;;KACf,CAAC,EAAE,CAAC;AACT,CAAC;AA/CD,sCA+CC;AACD,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,cAAM,CAAC,CAAC;AACrC,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,UAAE,CAAC,CAAC;AACjC,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,gBAAQ,CAAC,CAAC;AAEvC;;GAEG;AACH,SAAS,OAAO,CAAC,IAAY,EAAE,GAAW,EAAE,EAAU;IAClD,IAAI;QACA,OAAO,kBAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;KAC1C;IAAC,OAAO,GAAG,EAAE;QACV,IAAI,GAAG,YAAY,KAAK;YACpB,MAAM,IAAI,4BAAmB,CACzB,qFAAqF,CACxF,CAAC;;YACD,MAAM,GAAG,CAAC;KAClB;AACL,CAAC"}

package/lib/decorators/EncryptedController.d.ts

@@ -0,0 +1,31 @@
+import { IEncryptionPassword } from "@nestia/fetcher";
+/**
+ * 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 declare function EncryptedController(path: string, password: IEncryptionPassword | IEncryptionPassword.Closure): ClassDecorator;

package/lib/decorators/EncryptedController.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptedController = void 0;
+var common_1 = require("@nestjs/common");
+var EncryptedConstant_1 = require("./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
+ */
+function EncryptedController(path, password) {
+    return function (target) {
+        Reflect.defineMetadata(EncryptedConstant_1.ENCRYPTION_METADATA_KEY, password, target);
+        (0, common_1.Controller)(path)(target);
+    };
+}
+exports.EncryptedController = EncryptedController;
+//# sourceMappingURL=EncryptedController.js.map

package/lib/decorators/EncryptedController.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncryptedController.js","sourceRoot":"","sources":["../../src/decorators/EncryptedController.ts"],"names":[],"mappings":";;;AACA,yCAA4C;AAE5C,kEAAuE;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,SAAgB,mBAAmB,CAC/B,IAAY,EACZ,QAA2D;IAE3D,OAAO,UAAU,MAAW;QACxB,OAAO,CAAC,cAAc,CAAC,2CAAuB,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QAClE,IAAA,mBAAU,EAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC,CAAC;AACN,CAAC;AARD,kDAQC"}

package/lib/decorators/EncryptedModule.d.ts

@@ -0,0 +1,48 @@
+import { IEncryptionPassword } from "@nestia/fetcher/lib/IEncryptionPassword";
+import { ModuleMetadata } from "@nestjs/common";
+/**
+ * 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 declare function EncryptedModule(metadata: ModuleMetadata, password: IEncryptionPassword | IEncryptionPassword.Closure): ClassDecorator;
+export declare 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
+     */
+    function dynamic(path: string, password: IEncryptionPassword | IEncryptionPassword.Closure): Promise<object>;
+}

package/lib/decorators/EncryptedModule.js

@@ -0,0 +1,270 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptedModule = void 0;
+var common_1 = require("@nestjs/common");
+var detect_ts_node_1 = __importDefault(require("detect-ts-node"));
+var fs_1 = __importDefault(require("fs"));
+var EncryptedConstant_1 = require("./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
+ */
+function EncryptedModule(metadata, password) {
+    return function (target) {
+        var e_1, _a;
+        (0, common_1.Module)(metadata)(target);
+        if (metadata.controllers === undefined)
+            return;
+        try {
+            for (var _b = __values(metadata.controllers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var controller = _c.value;
+                if (Reflect.hasMetadata(EncryptedConstant_1.ENCRYPTION_METADATA_KEY, controller) ===
+                    false)
+                    Reflect.defineMetadata(EncryptedConstant_1.ENCRYPTION_METADATA_KEY, password, controller);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+}
+exports.EncryptedModule = EncryptedModule;
+(function (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
+     */
+    function dynamic(path, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var metadata, Module;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = {};
+                        return [4 /*yield*/, controllers(path, password)];
+                    case 1:
+                        metadata = (_a.controllers = _b.sent(),
+                            _a);
+                        Module = /** @class */ (function () {
+                            function Module() {
+                            }
+                            Module = __decorate([
+                                EncryptedModule(metadata, password)
+                            ], Module);
+                            return Module;
+                        }());
+                        return [2 /*return*/, Module];
+                }
+            });
+        });
+    }
+    EncryptedModule.dynamic = dynamic;
+    function controllers(path, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var output, output_1, output_1_1, controller;
+            var e_2, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        output = [];
+                        return [4 /*yield*/, iterate(output, path)];
+                    case 1:
+                        _b.sent();
+                        try {
+                            for (output_1 = __values(output), output_1_1 = output_1.next(); !output_1_1.done; output_1_1 = output_1.next()) {
+                                controller = output_1_1.value;
+                                if (Reflect.hasMetadata(EncryptedConstant_1.ENCRYPTION_METADATA_KEY, controller) ===
+                                    false)
+                                    Reflect.defineMetadata(EncryptedConstant_1.ENCRYPTION_METADATA_KEY, password, controller);
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (output_1_1 && !output_1_1.done && (_a = output_1.return)) _a.call(output_1);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        return [2 /*return*/, output];
+                }
+            });
+        });
+    }
+    function iterate(controllers, path) {
+        return __awaiter(this, void 0, void 0, function () {
+            var directory, directory_1, directory_1_1, file, current, stats, external_1, key, instance, e_3_1;
+            var e_3, _a;
+            return __generator(this, function (_b) {
+                var _c;
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, fs_1.default.promises.readdir(path)];
+                    case 1:
+                        directory = _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 10, 11, 12]);
+                        directory_1 = __values(directory), directory_1_1 = directory_1.next();
+                        _b.label = 3;
+                    case 3:
+                        if (!!directory_1_1.done) return [3 /*break*/, 9];
+                        file = directory_1_1.value;
+                        current = "".concat(path, "/").concat(file);
+                        return [4 /*yield*/, fs_1.default.promises.lstat(current)];
+                    case 4:
+                        stats = _b.sent();
+                        if (!(stats.isDirectory() === true)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, iterate(controllers, current)];
+                    case 5:
+                        _b.sent();
+                        return [3 /*break*/, 8];
+                    case 6:
+                        if (!(file.substring(file.length - 3) === ".".concat(EXTENSION))) return [3 /*break*/, 8];
+                        return [4 /*yield*/, (_c = current, Promise.resolve().then(function () { return __importStar(require(_c)); }))];
+                    case 7:
+                        external_1 = _b.sent();
+                        for (key in external_1) {
+                            instance = external_1[key];
+                            if (Reflect.getMetadata("path", instance) !== undefined)
+                                controllers.push(instance);
+                        }
+                        _b.label = 8;
+                    case 8:
+                        directory_1_1 = directory_1.next();
+                        return [3 /*break*/, 3];
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
+                        e_3_1 = _b.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 12];
+                    case 11:
+                        try {
+                            if (directory_1_1 && !directory_1_1.done && (_a = directory_1.return)) _a.call(directory_1);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/];
+                }
+            });
+        });
+    }
+})(EncryptedModule = exports.EncryptedModule || (exports.EncryptedModule = {}));
+var EXTENSION = detect_ts_node_1.default ? "ts" : "js";
+//# sourceMappingURL=EncryptedModule.js.map

package/lib/decorators/EncryptedModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncryptedModule.js","sourceRoot":"","sources":["../../src/decorators/EncryptedModule.ts"],"names":[],"mappings":"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"}

package/lib/decorators/EncryptedRoute.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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 declare namespace EncryptedRoute {
+    /**
+     * Encrypted router decorator function for the GET method.
+     *
+     * @param paths Path(s) of the HTTP request
+     * @returns Method decorator
+     */
+    const Get: {
+        (path?: string | string[]): MethodDecorator;
+        (stringify?: ((input: any) => string) | undefined): MethodDecorator;
+        (path: string | string[], stringify: (input: any) => string): MethodDecorator;
+    };
+    /**
+     * Encrypted router decorator function for the GET method.
+     *
+     * @param paths Path(s) of the HTTP request
+     * @returns Method decorator
+     */
+    const Post: {
+        (path?: string | string[]): MethodDecorator;
+        (stringify?: ((input: any) => string) | undefined): MethodDecorator;
+        (path: string | string[], stringify: (input: any) => string): MethodDecorator;
+    };
+    /**
+     * Encrypted router decorator function for the PATCH method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    const Patch: {
+        (path?: string | string[]): MethodDecorator;
+        (stringify?: ((input: any) => string) | undefined): MethodDecorator;
+        (path: string | string[], stringify: (input: any) => string): MethodDecorator;
+    };
+    /**
+     * Encrypted router decorator function for the PUT method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    const Put: {
+        (path?: string | string[]): MethodDecorator;
+        (stringify?: ((input: any) => string) | undefined): MethodDecorator;
+        (path: string | string[], stringify: (input: any) => string): MethodDecorator;
+    };
+    /**
+     * Encrypted router decorator function for the DELETE method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    const Delete: {
+        (path?: string | string[]): MethodDecorator;
+        (stringify?: ((input: any) => string) | undefined): MethodDecorator;
+        (path: string | string[], stringify: (input: any) => string): MethodDecorator;
+    };
+}