nestia 2.1.0-dev.20220414 → 2.1.0-dev.20220430

package/lib/generates/FunctionGenerator.js

@@ -0,0 +1,217 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionGenerator = void 0;
+var Pair_1 = require("tstl/utility/Pair");
+var Vector_1 = require("tstl/container/Vector");
+var FunctionGenerator;
+(function (FunctionGenerator) {
+    function generate(config, route) {
+        var query = route.parameters.find(function (param) { return param.category === "query"; });
+        var input = route.parameters.find(function (param) { return param.category === "body"; });
+        return [head, body, tail]
+            .map(function (closure) { return closure(route, query, input, config); })
+            .filter(function (str) { return !!str; })
+            .join("\n");
+    }
+    FunctionGenerator.generate = generate;
+    /* ---------------------------------------------------------
+        BODY
+    --------------------------------------------------------- */
+    function body(route, query, input, config) {
+        // FETCH ARGUMENTS WITH REQUST BODY
+        var parameters = filter_parameters(route, query);
+        var fetchArguments = [
+            "connection",
+            "".concat(route.name, ".ENCRYPTED"),
+            "".concat(route.name, ".METHOD"),
+            "".concat(route.name, ".path(").concat(parameters.map(function (p) { return p.name; }).join(", "), ")")
+        ];
+        if (input !== undefined) {
+            fetchArguments.push(input.name);
+            if (config.json === true)
+                fetchArguments.push("".concat(route.name, ".stringify"));
+        }
+        var assertions = config.assert === true && route.parameters.length !== 0
+            ? route.parameters
+                .map(function (param) { return "    assertType<typeof ".concat(param.name, ">(").concat(param.name, ");"); })
+                .join("\n") + "\n\n"
+            : "";
+        // RETURNS WITH FINALIZATION
+        return "{\n"
+            + assertions
+            + "    return Fetcher.fetch\n"
+            + "    (\n"
+            + fetchArguments.map(function (param) { return "        ".concat(param); }).join(",\n") + "\n"
+            + "    );\n"
+            + "}";
+    }
+    function filter_parameters(route, query) {
+        var parameters = route.parameters.filter(function (param) { return param.category === "param"; });
+        if (query)
+            parameters.push(query);
+        return parameters;
+    }
+    /* ---------------------------------------------------------
+        HEAD & TAIL
+    --------------------------------------------------------- */
+    function head(route, query, input) {
+        //----
+        // CONSTRUCT COMMENT
+        //----
+        // MAIN DESCRIPTION
+        var comments = route.comments
+            .map(function (part) { return "".concat(part.kind === "linkText" ? " " : "").concat(part.text); })
+            .map(function (str) { return str.split("\r\n").join("\n"); })
+            .join("")
+            .split("\n")
+            .filter(function (str, i, array) { return str !== "" || i !== array.length - 1; });
+        if (comments.length)
+            comments.push("");
+        // FILTER TAGS (VULNERABLE PARAMETERS WOULD BE REMOVED)
+        var tagList = route.tags.filter(function (tag) { return tag.text !== undefined; });
+        if (tagList.length !== 0) {
+            var index = tagList.findIndex(function (t) { return t.name === "param"; });
+            if (index !== -1) {
+                var capsule = Vector_1.Vector.wrap(tagList);
+                capsule.insert(capsule.nth(index), {
+                    name: "param",
+                    text: [
+                        {
+                            kind: "parameterName",
+                            text: "connection"
+                        },
+                        {
+                            kind: "space",
+                            text: " "
+                        },
+                        {
+                            kind: "text",
+                            text: "connection Information of the remote HTTP(s) server with headers (+encryption password)"
+                        }
+                    ]
+                });
+            }
+            comments.push.apply(comments, __spreadArray(__spreadArray([], __read(tagList.map(function (tag) { return "@".concat(tag.name, " ").concat(tag.text.map(function (elem) { return elem.text; }).join("")); })), false), [""], false));
+        }
+        // COMPLETE THE COMMENT
+        comments.push("@nestia Generated by Nestia - https://github.com/samchon/nestia", "@controller ".concat(route.symbol), "@path ".concat(route.method, " ").concat(route.path));
+        //----
+        // FINALIZATION
+        //----
+        // REFORM PARAMETERS TEXT
+        var parameters = __spreadArray([
+            "connection: IConnection"
+        ], __read(route.parameters.map(function (param) {
+            var type = (param === query || param === input)
+                ? "Primitive<".concat(route.name, ".").concat(param === query ? "Query" : "Input", ">")
+                : param.type.escapedText;
+            return "".concat(param.name, ": ").concat(type);
+        })), false);
+        // OUTPUT TYPE
+        var output = route.output.escapedText === "void"
+            ? "void"
+            : "".concat(route.name, ".Output");
+        // RETURNS WITH CONSTRUCTION
+        return ""
+            + "/**\n"
+            + comments.map(function (str) { return " * ".concat(str); }).join("\n") + "\n"
+            + " */\n"
+            + "export function ".concat(route.name, "\n")
+            + "    (\n"
+            + "".concat(parameters.map(function (str) { return "        ".concat(str); }).join(",\n"), "\n")
+            + "    ): Promise<".concat(output, ">");
+    }
+    function tail(route, query, input, config) {
+        // LIST UP TYPES
+        var types = [];
+        if (query !== undefined)
+            types.push(new Pair_1.Pair("Query", query.type.escapedText));
+        if (input !== undefined)
+            types.push(new Pair_1.Pair("Input", input.type.escapedText));
+        if (route.output.escapedText !== "void")
+            types.push(new Pair_1.Pair("Output", route.output.escapedText));
+        // PATH WITH PARAMETERS
+        var parameters = filter_parameters(route, query);
+        var path = compute_path(query, parameters, route.path);
+        return "export namespace ".concat(route.name, "\n")
+            + "{\n"
+            +
+                (types.length !== 0
+                    ? types.map(function (tuple) { return "    export type ".concat(tuple.first, " = Primitive<").concat(tuple.second, ">;"); }).join("\n") + "\n"
+                    : "")
+            + "\n"
+            + "    export const METHOD = \"".concat(route.method, "\" as const;\n")
+            + "    export const PATH: string = \"".concat(route.path, "\";\n")
+            + "    export const ENCRYPTED: Fetcher.IEncrypted = {\n"
+            + "        request: ".concat(input !== undefined && input.encrypted, ",\n")
+            + "        response: ".concat(route.encrypted, ",\n")
+            + "    };\n"
+            + "\n"
+            + "    export function path(".concat(parameters.map(function (param) { return "".concat(param.name, ": ").concat(param.type); }).join(", "), "): string\n")
+            + "    {\n"
+            + "        return ".concat(path, ";\n")
+            + "    }\n"
+            +
+                (config.json === true && (route.method === "POST" || route.method === "PUT" || route.method === "PATCH")
+                    ? "    export const stringify = createStringifier<Input>();\n"
+                    : "")
+            + "}";
+    }
+    function compute_path(query, parameters, path) {
+        var e_1, _a;
+        try {
+            for (var parameters_1 = __values(parameters), parameters_1_1 = parameters_1.next(); !parameters_1_1.done; parameters_1_1 = parameters_1.next()) {
+                var param = parameters_1_1.value;
+                if (param.category === "param")
+                    path = path.replace(":".concat(param.field), "${".concat(param.name, "}"));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (parameters_1_1 && !parameters_1_1.done && (_a = parameters_1.return)) _a.call(parameters_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return (query !== undefined)
+            ? "`".concat(path, "?${new URLSearchParams(").concat(query.name, " as any).toString()}`")
+            : "`".concat(path, "`");
+    }
+})(FunctionGenerator = exports.FunctionGenerator || (exports.FunctionGenerator = {}));
+//# sourceMappingURL=FunctionGenerator.js.map

package/lib/generates/SdkGenerator.d.ts

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import { IRoute } from "../structures/IRoute";
+import { IConfiguration } from "../IConfiguration";
+export declare namespace SdkGenerator {
+    function generate(_checker: ts.TypeChecker, config: IConfiguration, routeList: IRoute[]): Promise<void>;
+    const BUNDLE_PATH: string;
+}
+//# sourceMappingURL=SdkGenerator.d.ts.map

package/lib/generates/SdkGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdkGenerator.d.ts","sourceRoot":"","sources":["../../src/generates/SdkGenerator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAC;AAI5B,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,yBAAiB,YAAY,CAC7B;IACI,SAAsB,QAAQ,CAEtB,QAAQ,EAAE,EAAE,CAAC,WAAW,EACxB,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC,CA0BnB;IAEM,MAAM,WAAW,QAAiD,CAAC;CAC7E"}

package/lib/generates/SdkGenerator.js

@@ -0,0 +1,128 @@
+"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 (_) 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.SdkGenerator = void 0;
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var DirectoryUtil_1 = require("../utils/DirectoryUtil");
+var FileGenerator_1 = require("./FileGenerator");
+var SdkGenerator;
+(function (SdkGenerator) {
+    function generate(_checker, config, routeList) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, bundle, bundle_1, bundle_1_1, file, current, stats, content, e_1_1;
+            var e_1, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fs_1.default.promises.mkdir(config.output)];
+                    case 1:
+                        _c.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [4 /*yield*/, fs_1.default.promises.readdir(SdkGenerator.BUNDLE_PATH)];
+                    case 4:
+                        bundle = _c.sent();
+                        _c.label = 5;
+                    case 5:
+                        _c.trys.push([5, 12, 13, 14]);
+                        bundle_1 = __values(bundle), bundle_1_1 = bundle_1.next();
+                        _c.label = 6;
+                    case 6:
+                        if (!!bundle_1_1.done) return [3 /*break*/, 11];
+                        file = bundle_1_1.value;
+                        current = "".concat(SdkGenerator.BUNDLE_PATH, "/").concat(file);
+                        return [4 /*yield*/, fs_1.default.promises.stat(current)];
+                    case 7:
+                        stats = _c.sent();
+                        if (!(stats.isFile() === true)) return [3 /*break*/, 10];
+                        return [4 /*yield*/, fs_1.default.promises.readFile(current, "utf8")];
+                    case 8:
+                        content = _c.sent();
+                        return [4 /*yield*/, fs_1.default.promises.writeFile("".concat(config.output, "/").concat(file), content, "utf8")];
+                    case 9:
+                        _c.sent();
+                        _c.label = 10;
+                    case 10:
+                        bundle_1_1 = bundle_1.next();
+                        return [3 /*break*/, 6];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
+                        e_1_1 = _c.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (bundle_1_1 && !bundle_1_1.done && (_b = bundle_1.return)) _b.call(bundle_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 14: return [4 /*yield*/, DirectoryUtil_1.DirectoryUtil.copy(SdkGenerator.BUNDLE_PATH + "/__internal", config.output + "/__internal")];
+                    case 15:
+                        _c.sent();
+                        // FUNCTIONAL
+                        return [4 /*yield*/, FileGenerator_1.FileGenerator.generate(config, routeList)];
+                    case 16:
+                        // FUNCTIONAL
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    SdkGenerator.generate = generate;
+    SdkGenerator.BUNDLE_PATH = path_1.default.join(__dirname, "..", "..", "bundle");
+})(SdkGenerator = exports.SdkGenerator || (exports.SdkGenerator = {}));
+//# sourceMappingURL=SdkGenerator.js.map

package/lib/generates/SwaggerGenerator.d.ts

@@ -0,0 +1,7 @@
+import ts from "typescript";
+import { IConfiguration } from "../IConfiguration";
+import { IRoute } from "../structures/IRoute";
+export declare namespace SwaggerGenerator {
+    function generate(checker: ts.TypeChecker, config: IConfiguration.ISwagger, routeList: IRoute[]): Promise<void>;
+}
+//# sourceMappingURL=SwaggerGenerator.d.ts.map

package/lib/generates/SwaggerGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwaggerGenerator.d.ts","sourceRoot":"","sources":["../../src/generates/SwaggerGenerator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAC;AAK5B,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAK9C,yBAAiB,gBAAgB,CACjC;IACI,SAAsB,QAAQ,CAEtB,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,MAAM,EAAE,cAAc,CAAC,QAAQ,EAC/B,SAAS,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC,CAyCnB;CAyJJ"}

package/lib/generates/SwaggerGenerator.js

@@ -0,0 +1,258 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 (_) 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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerGenerator = void 0;
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var MetadataFactory_1 = require("typescript-json/lib/factories/MetadataFactory");
+var SchemaFactory_1 = require("typescript-json/lib/factories/SchemaFactory");
+var MapUtil_1 = require("../utils/MapUtil");
+var SwaggerGenerator;
+(function (SwaggerGenerator) {
+    function generate(checker, config, routeList) {
+        return __awaiter(this, void 0, void 0, function () {
+            var parsed, location, swagger, collection, pathDict, routeList_1, routeList_1_1, route, path, pathDict_1, pathDict_1_1, _a, path, routes;
+            var e_1, _b, e_2, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        parsed = path_1.default.parse(config.output);
+                        location = !!parsed.ext
+                            ? path_1.default.resolve(config.output)
+                            : path_1.default.join(path_1.default.resolve(config.output), "swagger.json");
+                        return [4 /*yield*/, initialize(location)];
+                    case 1:
+                        swagger = _d.sent();
+                        collection = new MetadataFactory_1.MetadataFactory.Collection(false);
+                        pathDict = new Map();
+                        try {
+                            for (routeList_1 = __values(routeList), routeList_1_1 = routeList_1.next(); !routeList_1_1.done; routeList_1_1 = routeList_1.next()) {
+                                route = routeList_1_1.value;
+                                path = MapUtil_1.MapUtil.take(pathDict, get_path(route.path, route.parameters), function () { return ({}); });
+                                path[route.method.toLowerCase()] = generate_route(checker, collection, route);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (routeList_1_1 && !routeList_1_1.done && (_b = routeList_1.return)) _b.call(routeList_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        swagger.paths = {};
+                        try {
+                            for (pathDict_1 = __values(pathDict), pathDict_1_1 = pathDict_1.next(); !pathDict_1_1.done; pathDict_1_1 = pathDict_1.next()) {
+                                _a = __read(pathDict_1_1.value, 2), path = _a[0], routes = _a[1];
+                                swagger.paths[path] = routes;
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (pathDict_1_1 && !pathDict_1_1.done && (_c = pathDict_1.return)) _c.call(pathDict_1);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        swagger.components = __assign({}, SchemaFactory_1.SchemaFactory.components(collection.storage()));
+                        swagger.nestia = "Generated by Nestia - https://github.com/samchon/nestia";
+                        return [4 /*yield*/, fs_1.default.promises.writeFile(location, JSON.stringify(swagger, null, 2), "utf8")];
+                    case 2:
+                        _d.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    SwaggerGenerator.generate = generate;
+    function initialize(path) {
+        return __awaiter(this, void 0, void 0, function () {
+            var swagger, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!fs_1.default.existsSync(path)) return [3 /*break*/, 2];
+                        _c = (_b = JSON).parse;
+                        return [4 /*yield*/, fs_1.default.promises.readFile(path, "utf8")];
+                    case 1:
+                        _a = _c.apply(_b, [_d.sent()]);
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = {
+                            openapi: "3.0",
+                            nestia: "",
+                            paths: {},
+                            components: {}
+                        };
+                        _d.label = 3;
+                    case 3:
+                        swagger = _a;
+                        // RETURNS
+                        return [2 /*return*/, swagger];
+                }
+            });
+        });
+    }
+    function get_path(path, parameters) {
+        var e_3, _a;
+        var filtered = parameters.filter(function (param) { return param.category === "param"
+            && !!param.field; });
+        try {
+            for (var filtered_1 = __values(filtered), filtered_1_1 = filtered_1.next(); !filtered_1_1.done; filtered_1_1 = filtered_1.next()) {
+                var param = filtered_1_1.value;
+                path = path.replace(":".concat(param.field), "{".concat(param.field, "}"));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (filtered_1_1 && !filtered_1_1.done && (_a = filtered_1.return)) _a.call(filtered_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return path;
+    }
+    function generate_route(checker, collection, route) {
+        var bodyParam = route.parameters.find(function (param) { return param.category === "body"; });
+        return {
+            tags: [],
+            parameters: route.parameters
+                .filter(function (param) { return param.category !== "body"; })
+                .map(function (param) { return generate_parameter(checker, collection, route, param); }),
+            requestBody: bodyParam
+                ? generate_request_body(checker, collection, route, bodyParam)
+                : undefined,
+            responses: generate_response_body(checker, collection, route)
+        };
+    }
+    function generate_parameter(checker, collection, route, parameter) {
+        return {
+            name: parameter.name,
+            in: parameter.category === "param"
+                ? "path"
+                : parameter.category,
+            description: get_parametric_description(route.comments, "parameterName", parameter.name),
+            schema: generate_schema(checker, collection, parameter.type.metadata),
+            required: true
+        };
+    }
+    function generate_request_body(checker, collection, route, parameter) {
+        return {
+            description: get_parametric_description(route.comments, "parameterName", parameter.name),
+            content: {
+                "application/json": {
+                    schema: generate_schema(checker, collection, route.output.metadata)
+                }
+            },
+            required: true
+        };
+    }
+    function generate_response_body(checker, collection, route) {
+        var _a;
+        var status = route.method === "GET" || route.method === "DELETE"
+            ? "200"
+            : "201";
+        return _a = {},
+            _a[status] = {
+                description: get_parametric_description(route.comments, "return")
+                    || get_parametric_description(route.comments, "returns"),
+                content: route.output.escapedText === "void" ? undefined :
+                    {
+                        "application/json": {
+                            schema: generate_schema(checker, collection, route.output.metadata)
+                        }
+                    }
+            },
+            _a;
+    }
+    function get_parametric_description(comments, kind, text) {
+        var _a;
+        var index = comments.findIndex(function (c) {
+            return c.kind === kind &&
+                (c.text === text || !text);
+        });
+        return index !== -1
+            ? (_a = comments[index + 2]) === null || _a === void 0 ? void 0 : _a.text
+            : undefined;
+    }
+    function generate_schema(checker, collection, type) {
+        var entity = MetadataFactory_1.MetadataFactory.generate(checker, type, collection);
+        return SchemaFactory_1.SchemaFactory.schema((entity === null || entity === void 0 ? void 0 : entity.metadata) || null);
+    }
+})(SwaggerGenerator = exports.SwaggerGenerator || (exports.SwaggerGenerator = {}));
+//# sourceMappingURL=SwaggerGenerator.js.map

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import * as nestia from "./module";
+export default nestia;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,eAAe,MAAM,CAAC"}

package/lib/index.js

@@ -0,0 +1,28 @@
+"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 __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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var nestia = __importStar(require("./module"));
+exports.default = nestia;
+//# sourceMappingURL=index.js.map