nestia 2.0.0 → 2.0.1-dev.20220413-2

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "nestia",
-  "version": "2.0.0",
+  "version": "2.0.1-dev.20220413-2",
   "description": "Automatic SDK and Document generator for the NestJS",
   "main": "src/index.ts",
   "bin": {
-    "nestia": "./src/bin/nestia.ts"
+    "nestia": "./src/bin/nestia.js"
   },
   "scripts": {
+    "build": "tsc src/bin/nestia.ts",
     "dev": "tsc --watch",
     "test": "cd test && bash script.sh",
     "test:default": "cd test/default && rimraf -rf src/api/functional && ts-node ../../src/bin/nestia sdk src/controllers --out src/api"
@@ -31,15 +32,17 @@
   "dependencies": {
     "@types/cli": "^0.11.19",
     "@types/glob": "^7.2.0",
-    "@types/node": "^14.14.22",
+    "@types/node": "^17.0.23",
     "@types/reflect-metadata": "^0.1.0",
     "cli": "^1.0.1",
     "del": "^6.0.0",
     "glob": "^7.2.0",
     "ts-node": "^9.1.1",
-    "tsconfig-paths": "^3.14.1",
     "tstl": "^2.5.3",
-    "typescript": "^4.6.3"
+    "ttypescript": "^1.5.13",
+    "typescript": "^4.5.3",
+    "typescript-is": "^0.19.0",
+    "typescript-transform-paths": "^3.3.1"
   },
   "devDependencies": {
     "nestia-helper": "^2.0.0",

package/src/IConfiguration.ts

@@ -5,6 +5,7 @@ export interface IConfiguration
     input: string | string[] | IConfiguration.IInput;
     output: string;
     compilerOptions?: tsc.CompilerOptions;
+    assert?: boolean;
 }
 export namespace IConfiguration
 {

package/src/NestiaApplication.ts

@@ -1,6 +1,6 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as tsc from "typescript";
+import fs from "fs";
+import path from "path";
+import tsc from "typescript";
 import { Pair } from "tstl/utility/Pair";
 import { Singleton } from "tstl/thread/Singleton";
 
@@ -85,7 +85,7 @@ export class NestiaApplication
         }
 
         // DO GENERATE
-        await SdkGenerator.generate(this.config_.output, routeList);
+        await SdkGenerator.generate(this.config_, routeList);
     }
 
     private async is_not_excluded(file: string): Promise<boolean>

package/src/analyses/ControllerAnalyzer.ts

@@ -1,5 +1,5 @@
-import * as NodePath from "path";
-import * as tsc from "typescript";
+import NodePath from "path";
+import tsc from "typescript";
 import { HashMap } from "tstl/container/HashMap";
 
 import { IController } from "../structures/IController";

package/src/analyses/GenericAnalyzer.ts

@@ -1,4 +1,4 @@
-import * as tsc from "typescript";
+import tsc from "typescript";
 
 export namespace GenericAnalyzer
 {

package/src/analyses/ImportAnalyzer.ts

@@ -1,4 +1,4 @@
-import * as tsc from "typescript";
+import tsc from "typescript";
 
 import { HashMap } from "tstl/container/HashMap";
 import { HashSet } from "tstl/container/HashSet";

package/src/bin/nestia.js

@@ -0,0 +1,160 @@
+"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 __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));
+};
+exports.__esModule = true;
+var cp = require("child_process");
+var fs = require("fs");
+var CompilerOptions_1 = require("../internal/CompilerOptions");
+var stripJsonComments_1 = require("../utils/stripJsonComments");
+function install() {
+    // INSTALL DEPENDENCIES
+    for (var _i = 0, _a = ["nestia-fetcher", "typescript-is"]; _i < _a.length; _i++) {
+        var lib = _a[_i];
+        var command = "npm install ".concat(lib);
+        cp.execSync(command, { stdio: "inherit" });
+    }
+}
+function sdk() {
+    // PREPARE COMMAND
+    var parameters = __spreadArray([
+        "npx ts-node -C ttypescript",
+        __dirname + "/../executable/sdk"
+    ], process.argv.slice(3), true);
+    var command = parameters.join(" ");
+    // EXECUTE THE COMMAND, BUT IGNORE WARNINGS
+    cp.execSync(command, {
+        stdio: "inherit",
+        env: { "NODE_NO_WARNINGS": "1" }
+    });
+}
+function configure(config) {
+    if (!config.compilerOptions) {
+        config.compilerOptions = CompilerOptions_1.CompilerOptions.DEFAULT;
+        return true;
+    }
+    else
+        return CompilerOptions_1.CompilerOptions.emend(config.compilerOptions);
+}
+function tsconfig(task) {
+    return __awaiter(this, void 0, void 0, function () {
+        var prepare, restore, config_1, content_1, config_2, changed, error;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    prepare = null;
+                    restore = null;
+                    if (!(fs.existsSync("tsconfig.json") === false)) return [3 /*break*/, 1];
+                    config_1 = {
+                        compilerOptions: CompilerOptions_1.CompilerOptions.DEFAULT
+                    };
+                    prepare = function () { return fs.promises.writeFile("tsconfig.json", JSON.stringify(config_1, null, 2), "utf8"); };
+                    restore = function () { return fs.promises.unlink("tsconfig.json"); };
+                    return [3 /*break*/, 3];
+                case 1: return [4 /*yield*/, fs.promises.readFile("tsconfig.json", "utf8")];
+                case 2:
+                    content_1 = _a.sent();
+                    config_2 = JSON.parse((0, stripJsonComments_1.stripJsonComments)(content_1));
+                    changed = configure(config_2);
+                    if (changed === true) {
+                        // NEED TO ADD TRANSFORM PLUGINS
+                        prepare = function () { return fs.promises.writeFile("tsconfig.json", JSON.stringify(config_2, null, 2), "utf8"); };
+                        restore = function () { return fs.promises.writeFile("tsconfig.json", content_1, "utf8"); };
+                    }
+                    _a.label = 3;
+                case 3:
+                    if (!(prepare !== null)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, prepare()];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5:
+                    error = null;
+                    try {
+                        task();
+                    }
+                    catch (exp) {
+                        error = exp;
+                    }
+                    if (!(restore !== null)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, restore()];
+                case 6:
+                    _a.sent();
+                    _a.label = 7;
+                case 7:
+                    // THROW ERROR IF EXISTS
+                    if (error)
+                        throw error;
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(process.argv[2] === "install")) return [3 /*break*/, 2];
+                    return [4 /*yield*/, install()];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 2:
+                    if (!(process.argv[2] === "sdk")) return [3 /*break*/, 4];
+                    return [4 /*yield*/, tsconfig(sdk)];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 4: throw new Error("nestia supports only two commands; install and sdk, however you typed ".concat(process.argv[2]));
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+main()["catch"](function (exp) {
+    console.log(exp.message);
+    process.exit(-1);
+});

package/src/bin/nestia.ts

@@ -1,85 +1,126 @@
-#!/usr/bin/env ts-node
-
-import cp from "child_process";
-import fs from "fs";
-import tsc from "typescript";
+import * as cp from "child_process";
+import * as fs from "fs";
 
+import { CompilerOptions } from "../internal/CompilerOptions";
 import { stripJsonComments } from "../utils/stripJsonComments";
 
+interface IConfig
+{
+    compilerOptions?: CompilerOptions;
+}
+
 function install(): void
 {
-    const command: string = "npm install --save nestia-fetcher";
-    cp.execSync(command, { stdio: "inherit" });
+    // INSTALL DEPENDENCIES
+    for (const lib of ["nestia-fetcher", "typescript-is"])
+    {
+        const command: string = `npm install ${lib}`;
+        cp.execSync(command, { stdio: "inherit" });
+    }
 }
 
-function sdk(alias: boolean): void
+function sdk(): void
 {
+    // PREPARE COMMAND
     const parameters: string[] = [
-        alias ? "npx ts-node -r tsconfig-paths/register" : "npx ts-node",
+        "npx ts-node -C ttypescript",
         __dirname + "/../executable/sdk",
         ...process.argv.slice(3)
     ];
     const command: string = parameters.join(" ");
-    cp.execSync(command, { stdio: "inherit" });
+
+    // EXECUTE THE COMMAND, BUT IGNORE WARNINGS
+    cp.execSync
+    (
+        command, 
+        { 
+            stdio: "inherit",
+            env: { "NODE_NO_WARNINGS": "1" } 
+        }
+    );
 }
 
-async function tsconfig(task: (alias: boolean) => void): Promise<void>
+function configure(config: IConfig): boolean
 {
-    // NO TSCONFIG.JSON?
-    if (fs.existsSync("tsconfig.json") === false)
-    {
-        task(false);
-        return;
-    }
-
-    const content: string = await fs.promises.readFile("tsconfig.json", "utf8");
-    const json: any = JSON.parse(stripJsonComments(content));
-    const options: tsc.CompilerOptions = json.compilerOptions;
-
-    // NO ALIAS PATHS
-    if (!options.paths || !Object.entries(options.paths).length)
+    if (!config.compilerOptions)
     {
-        task(false);
-        return;
+        config.compilerOptions = CompilerOptions.DEFAULT;
+        return true;
     }
+    else
+        return CompilerOptions.emend(config.compilerOptions);
+}
 
-    let closer: null | (() => Promise<void>) = null;
-    let error: Error | null = null;
+async function tsconfig(task: () => void): Promise<void>
+{
+    //----
+    // PREPARE ASSETS
+    //----
+    let prepare: null | (() => Promise<void>) = null;
+    let restore: null | (() => Promise<void>) = null;
 
-    if (!options.baseUrl)
+    if (fs.existsSync("tsconfig.json") === false)
     {
-        options.baseUrl = "./";
-        await fs.promises.writeFile
+        // NO TSCONFIG.JSON
+        const config: IConfig = {
+            compilerOptions: CompilerOptions.DEFAULT
+        };
+        prepare = () => fs.promises.writeFile
         (
-            "tsconfig.json", 
-            JSON.stringify(json, null, 2),
+            "tsconfig.json",
+            JSON.stringify(config, null, 2),
             "utf8"
         );
+        restore = () => fs.promises.unlink("tsconfig.json")
+    }
+    else
+    {
+        // HAS TSCONFIG.JSON
+        const content: string = await fs.promises.readFile("tsconfig.json", "utf8");
+        const config: IConfig = JSON.parse(stripJsonComments(content));
+        const changed: boolean = configure(config);
 
-        closer = () => fs.promises.writeFile
-        (
-            "tsconfig.json", 
-            content, 
-            "utf8"
-        );
+        if (changed === true)
+        {
+            // NEED TO ADD TRANSFORM PLUGINS
+            prepare = () => fs.promises.writeFile
+            (
+                "tsconfig.json", 
+                JSON.stringify(config, null, 2),
+                "utf8"
+            );
+            restore = () => fs.promises.writeFile("tsconfig.json", content, "utf8");
+        }
     }
 
+    //----
+    // EXECUTION
+    //----
+    // PREPARE SOMETHING
+    if (prepare !== null)
+        await prepare();
+
+    // EXECUTE THE TASK
+    let error: Error | null = null;
     try
     {
-        task(true);
+        task();
     }
     catch (exp)
     {
         error = exp as Error;
     }
 
-    if (closer)
-        await closer();
+    // RESTORE THE TSCONFIG.JSON
+    if (restore !== null)
+        await restore();
+
+    // THROW ERROR IF EXISTS
     if (error)
         throw error;
 }
 
-async function main(): Promise<void>
+async function main()
 {
     if (process.argv[2] === "install")
         await install();

package/src/generates/FileGenerator.ts

@@ -1,5 +1,6 @@
-import * as fs from "fs";
+import fs from "fs";
 import { HashMap } from "tstl/container/HashMap";
+import { IConfiguration } from "../IConfiguration";
 
 import { IRoute } from "../structures/IRoute";
 import { ImportDictionary } from "../utils/ImportDictionary";
@@ -10,7 +11,7 @@ export namespace FileGenerator
     /* ---------------------------------------------------------
         CONSTRUCTOR
     --------------------------------------------------------- */
-    export async function generate(outDir: string, routeList: IRoute[]): Promise<void>
+    export async function generate(config: IConfiguration, routeList: IRoute[]): Promise<void>
     {
         // CONSTRUCT FOLDER TREE
         const root: Directory = new Directory(null, "functional");
@@ -21,7 +22,7 @@ export namespace FileGenerator
         relocate(root);
 
         // ITERATE FILES
-        await iterate(outDir + "/functional", root);
+        await iterate(!!config.assert, config.output + "/functional", root);
     }
 
     function emplace(directory: Directory, route: IRoute): void
@@ -63,7 +64,12 @@ export namespace FileGenerator
     /* ---------------------------------------------------------
         FILE ITERATOR
     --------------------------------------------------------- */
-    async function iterate(outDir: string, directory: Directory): Promise<void>
+    async function iterate
+        (
+            assert: boolean, 
+            outDir: string, 
+            directory: Directory
+        ): Promise<void>
     {
         // CREATE A NEW DIRECTORY
         try
@@ -76,7 +82,7 @@ export namespace FileGenerator
         let content: string = "";
         for (const it of directory.directories)
         {
-            await iterate(`${outDir}/${it.first}`, it.second);
+            await iterate(assert, `${outDir}/${it.first}`, it.second);
             content += `export * as ${it.first} from "./${it.first}";\n`;
         }
         content += "\n";
@@ -88,27 +94,34 @@ export namespace FileGenerator
             for (const tuple of route.imports)
                 for (const instance of tuple[1])
                     importDict.emplace(tuple[0], false, instance);
-            content += FunctionGenerator.generate(route) + "\n\n";
+            content += FunctionGenerator.generate(assert, route) + "\n\n";
         }
 
         // FINALIZE THE CONTENT
         if (directory.routes.length !== 0)
+        {
+            const primitived: boolean = directory.routes.some(route => route.output !== "void" 
+                || route.parameters.some(param => param.category !== "param")
+            );
+            const asserted: boolean = assert 
+                && directory.routes.some(route => route.parameters.length !== 0);
+            
+            const fetcher: string[] = ["Fetcher"];
+            if (primitived) 
+                fetcher.push("Primitive");
+            
             content = ""
-                + `import { AesPkcs5, Fetcher, Primitive } from "nestia-fetcher";\n`
+                + `import { ${fetcher.join(", ")} } from "nestia-fetcher";\n`
                 + `import type { IConnection } from "nestia-fetcher";\n`
+                + (asserted ? `import { assertType } from "typescript-is";\n` : "")
                 + 
                 (
                     importDict.empty()
                         ? ""
                         : "\n" + importDict.toScript(outDir) + "\n"
                 )
-                + content + "\n\n"
-                + "//---------------------------------------------------------\n"
-                + "// TO PREVENT THE UNUSED VARIABLE ERROR\n"
-                + "//---------------------------------------------------------\n"
-                + "AesPkcs5;\n"
-                + "Fetcher;\n"
-                + "Primitive;";
+                + content;
+        }
 
         content = "/**\n"
             + " * @packageDocumentation\n"

package/src/generates/FunctionGenerator.ts

@@ -1,4 +1,4 @@
-import type * as tsc from "typescript";
+import type tsc from "typescript";
 import { Pair } from "tstl/utility/Pair";
 import { Vector } from "tstl/container/Vector";
 
@@ -6,13 +6,13 @@ import { IRoute } from "../structures/IRoute";
 
 export namespace FunctionGenerator
 {
-    export function generate(route: IRoute): string
+    export function generate(assert: boolean, route: IRoute): string
     {
         const query: IRoute.IParameter | undefined = route.parameters.find(param => param.category === "query");
         const input: IRoute.IParameter | undefined = route.parameters.find(param => param.category === "body");
 
         return [head, body, tail]
-            .map(closure => closure(route, query, input))
+            .map(closure => closure(route, query, input, assert))
             .filter(str => !!str)
             .join("\n");
     }
@@ -20,7 +20,13 @@ export namespace FunctionGenerator
     /* ---------------------------------------------------------
         BODY
     --------------------------------------------------------- */
-    function body(route: IRoute, query: IRoute.IParameter | undefined, input: IRoute.IParameter | undefined): string
+    function body
+        (
+            route: IRoute, 
+            query: IRoute.IParameter | undefined, 
+            input: IRoute.IParameter | undefined,
+            assert: boolean
+        ): string
     {
         // FETCH ARGUMENTS WITH REQUST BODY
         const parameters = filter_parameters(route, query);
@@ -34,8 +40,15 @@ export namespace FunctionGenerator
         if (input !== undefined)
             fetchArguments.push(input.name);
 
+        const assertions: string = assert === true && route.parameters.length !== 0
+            ? route.parameters
+                .map(param => `    assertType<typeof ${param.name}>(${param.name});`)
+                .join("\n") + "\n\n"
+            : "";
+
         // RETURNS WITH FINALIZATION
         return "{\n"
+            + assertions
             + "    return Fetcher.fetch\n"
             + "    (\n"
             + fetchArguments.map(param => `        ${param}`).join(",\n") + "\n"
@@ -54,7 +67,12 @@ export namespace FunctionGenerator
     /* ---------------------------------------------------------
         HEAD & TAIL
     --------------------------------------------------------- */
-    function head(route: IRoute, query: IRoute.IParameter | undefined, input: IRoute.IParameter | undefined): string
+    function head
+        (
+            route: IRoute, 
+            query: IRoute.IParameter | undefined, 
+            input: IRoute.IParameter | undefined
+        ): string
     {
         //----
         // CONSTRUCT COMMENT
@@ -132,7 +150,12 @@ export namespace FunctionGenerator
             + `    ): Promise<${output}>`;
     }
 
-    function tail(route: IRoute, query: IRoute.IParameter | undefined, input: IRoute.IParameter | undefined): string | null
+    function tail
+        (
+            route: IRoute, 
+            query: IRoute.IParameter | undefined, 
+            input: IRoute.IParameter | undefined
+        ): string | null
     {
         // LIST UP TYPES
         const types: Pair<string, string>[] = [];

package/src/generates/SdkGenerator.ts

@@ -1,15 +1,20 @@
-import * as fs from "fs";
+import fs from "fs";
 import { DirectoryUtil } from "../utils/DirectoryUtil";
 
 import { IRoute } from "../structures/IRoute";
 import { FileGenerator } from "./FileGenerator";
+import { IConfiguration } from "../IConfiguration";
 
 export namespace SdkGenerator
 {
-    export async function generate(outDir: string, routeList: IRoute[]): Promise<void>
+    export async function generate
+        (
+            config: IConfiguration,
+            routeList: IRoute[],
+        ): Promise<void>
     {
         // PREPARE NEW DIRECTORIES
-        try { await fs.promises.mkdir(outDir); } catch {}
+        try { await fs.promises.mkdir(config.output); } catch {}
 
         // BUNDLING
         const bundle: string[] = await fs.promises.readdir(BUNDLE);
@@ -21,13 +26,13 @@ export namespace SdkGenerator
             if (stats.isFile() === true)
             {
                 const content: string = await fs.promises.readFile(current, "utf8");
-                await fs.promises.writeFile(`${outDir}/${file}`, content, "utf8");
+                await fs.promises.writeFile(`${config.output}/${file}`, content, "utf8");
             }
         }
-        await DirectoryUtil.copy(BUNDLE + "/__internal", outDir + "/__internal");
+        await DirectoryUtil.copy(BUNDLE + "/__internal", config.output + "/__internal");
         
         // FUNCTIONAL
-        await FileGenerator.generate(outDir, routeList);
+        await FileGenerator.generate(config, routeList);
     }
 }
 

package/src/internal/CompilerOptions.js

@@ -0,0 +1,94 @@
+"use strict";
+exports.__esModule = true;
+exports.CompilerOptions = void 0;
+var CompilerOptions;
+(function (CompilerOptions) {
+    CompilerOptions.DEPENDENCIES = [
+        "nestia-fetcher",
+        "typescript-is"
+    ];
+    CompilerOptions.TRANSFORMERS = [
+        "typescript-is/lib/transform-inline/transformer",
+        "typescript-transform-paths"
+    ];
+    CompilerOptions.TYPES = [];
+    CompilerOptions.DEFAULT = {
+        target: "es5",
+        module: "commonjs",
+        lib: [
+            "DOM",
+            "ES2015"
+        ],
+        strict: true,
+        downlevelIteration: true,
+        esModuleInterop: true,
+        plugins: CompilerOptions.TRANSFORMERS.map(function (transform) { return ({ transform: transform }); }),
+        types: [
+            "node",
+            "reflect-metadata"
+        ],
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true
+    };
+    function emend(options) {
+        // FILL ARRAY DATA
+        if (!options.plugins)
+            options.plugins = [];
+        if (!options.types)
+            options.types = [];
+        // CONSTRUCT CHECKERS
+        var emended = options;
+        var checkers = [
+            function () {
+                var changed = false;
+                var _loop_1 = function (transform) {
+                    if (emended.plugins.find(function (elem) { return elem.transform === transform; }) !== undefined)
+                        return "continue";
+                    changed = true;
+                    emended.plugins.push({ transform: transform });
+                };
+                for (var _i = 0, _a = CompilerOptions.TRANSFORMERS; _i < _a.length; _i++) {
+                    var transform = _a[_i];
+                    _loop_1(transform);
+                }
+                return changed;
+            },
+            function () {
+                var changed = false;
+                var _loop_2 = function (type) {
+                    if (emended.types.find(function (elem) { return elem === type; }) !== undefined)
+                        return "continue";
+                    changed = true;
+                    emended.types.push(type);
+                };
+                for (var _i = 0, _a = CompilerOptions.TYPES; _i < _a.length; _i++) {
+                    var type = _a[_i];
+                    _loop_2(type);
+                }
+                return changed;
+            },
+            function () {
+                var changed = emended.experimentalDecorators !== true;
+                if (changed)
+                    emended.experimentalDecorators = true;
+                return changed;
+            },
+            function () {
+                var changed = emended.emitDecoratorMetadata !== true;
+                if (changed)
+                    emended.emitDecoratorMetadata = true;
+                return changed;
+            },
+            function () {
+                var changed = emended.esModuleInterop !== true;
+                if (changed)
+                    emended.esModuleInterop = true;
+                return changed;
+            }
+        ];
+        // DO CHECK IT
+        var checks = checkers.map(function (func) { return func(); });
+        return checks.some(function (flag) { return flag; });
+    }
+    CompilerOptions.emend = emend;
+})(CompilerOptions = exports.CompilerOptions || (exports.CompilerOptions = {}));

package/src/internal/CompilerOptions.ts

@@ -0,0 +1,113 @@
+export interface CompilerOptions
+{
+    target: string;
+    module: string;
+    lib: string[];
+    strict: boolean;
+    downlevelIteration: boolean;
+    esModuleInterop?: boolean;
+    plugins?: Array<{ 
+        transform?: string 
+    }>;
+    types?: string[];
+    experimentalDecorators?: boolean;
+    emitDecoratorMetadata?: boolean;
+}
+export namespace CompilerOptions
+{   
+    export const DEPENDENCIES: string[] = [
+        "nestia-fetcher", 
+        "typescript-is"
+    ];
+
+    export const TRANSFORMERS: string[] = [
+        "typescript-is/lib/transform-inline/transformer", 
+        "typescript-transform-paths"
+    ];
+
+    export const TYPES: string[] = []
+
+    export const DEFAULT = {
+        target: "es5",
+        module: "commonjs",
+        lib: [
+            "DOM", 
+            "ES2015"
+        ],
+        strict: true,
+        downlevelIteration: true,
+        esModuleInterop: true,
+        plugins: TRANSFORMERS.map(transform => ({ transform })),
+        types: [
+            "node",
+            "reflect-metadata"
+        ],
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+    };
+
+    export function emend(options: CompilerOptions): boolean
+    {
+        // FILL ARRAY DATA
+        if (!options.plugins)
+            options.plugins = [];
+        if (!options.types)
+            options.types = [];
+        
+        // CONSTRUCT CHECKERS
+        const emended: Required<CompilerOptions> = options as Required<CompilerOptions>;
+        const checkers: Array<() => boolean> = [
+            () => 
+            {
+                let changed: boolean = false;
+                for (const transform of CompilerOptions.TRANSFORMERS)
+                {
+                    if (emended.plugins.find(elem => elem.transform === transform) !== undefined)
+                        continue;
+    
+                    changed = true;
+                    emended.plugins.push({ transform });
+                }
+                return changed;
+            },
+            () =>
+            {
+                let changed: boolean = false;
+                for (const type of CompilerOptions.TYPES)
+                {
+                    if (emended.types.find(elem => elem === type) !== undefined)
+                        continue;
+    
+                    changed = true;
+                    emended.types.push(type);
+                }
+                return changed;
+            },
+            () =>
+            {
+                const changed: boolean = emended.experimentalDecorators !== true;
+                if (changed)
+                    emended.experimentalDecorators = true;
+                return changed;
+            },
+            () =>
+            {
+                const changed: boolean = emended.emitDecoratorMetadata !== true;
+                if (changed)
+                    emended.emitDecoratorMetadata = true;
+                return changed;
+            },
+            () =>
+            {
+                const changed: boolean = emended.esModuleInterop !== true;
+                if (changed)
+                    emended.esModuleInterop = true;
+                return changed;
+            }
+        ];
+
+        // DO CHECK IT
+        const checks: boolean[] = checkers.map(func => func());
+        return checks.some(flag => flag);
+    }
+}

package/src/structures/IRoute.ts

@@ -1,4 +1,4 @@
-import type * as tsc from "typescript";
+import type tsc from "typescript";
 import { ParamCategory } from "./ParamCategory";
 
 export interface IRoute

package/src/utils/DirectoryUtil.ts

@@ -1,5 +1,5 @@
 import del from "del";
-import * as fs from "fs";
+import fs from "fs";
 
 export namespace DirectoryUtil
 {

package/src/utils/ImportDictionary.ts

@@ -1,4 +1,4 @@
-import * as path from "path";
+import path from "path";
 
 import { HashMap } from "tstl/container/HashMap";
 import { HashSet } from "tstl/container/HashSet";

package/src/utils/stripJsonComments.js

@@ -0,0 +1,75 @@
+"use strict";
+// https://github.com/sindresorhus/strip-json-comments
+exports.__esModule = true;
+exports.stripJsonComments = void 0;
+var singleComment = Symbol('singleComment');
+var multiComment = Symbol('multiComment');
+var stripWithoutWhitespace = function () { return ''; };
+var stripWithWhitespace = function (string, start, end) { return string.slice(start, end).replace(/\S/g, ' '); };
+var isEscaped = function (jsonString, quotePosition) {
+    var index = quotePosition - 1;
+    var backslashCount = 0;
+    while (jsonString[index] === '\\') {
+        index -= 1;
+        backslashCount += 1;
+    }
+    return Boolean(backslashCount % 2);
+};
+function stripJsonComments(jsonString, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.whitespace, whitespace = _c === void 0 ? true : _c;
+    if (typeof jsonString !== 'string') {
+        throw new TypeError("Expected argument `jsonString` to be a `string`, got `".concat(typeof jsonString, "`"));
+    }
+    var strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace;
+    var isInsideString = false;
+    var isInsideComment = false;
+    var offset = 0;
+    var result = '';
+    for (var index = 0; index < jsonString.length; index++) {
+        var currentCharacter = jsonString[index];
+        var nextCharacter = jsonString[index + 1];
+        if (!isInsideComment && currentCharacter === '"') {
+            var escaped = isEscaped(jsonString, index);
+            if (!escaped) {
+                isInsideString = !isInsideString;
+            }
+        }
+        if (isInsideString) {
+            continue;
+        }
+        if (!isInsideComment && currentCharacter + nextCharacter === '//') {
+            result += jsonString.slice(offset, index);
+            offset = index;
+            isInsideComment = singleComment;
+            index++;
+        }
+        else if (isInsideComment === singleComment && currentCharacter + nextCharacter === '\r\n') {
+            index++;
+            isInsideComment = false;
+            result += strip(jsonString, offset, index);
+            offset = index;
+            continue;
+        }
+        else if (isInsideComment === singleComment && currentCharacter === '\n') {
+            isInsideComment = false;
+            result += strip(jsonString, offset, index);
+            offset = index;
+        }
+        else if (!isInsideComment && currentCharacter + nextCharacter === '/*') {
+            result += jsonString.slice(offset, index);
+            offset = index;
+            isInsideComment = multiComment;
+            index++;
+            continue;
+        }
+        else if (isInsideComment === multiComment && currentCharacter + nextCharacter === '*/') {
+            index++;
+            isInsideComment = false;
+            result += strip(jsonString, offset, index + 1);
+            offset = index + 1;
+            continue;
+        }
+    }
+    return result + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+}
+exports.stripJsonComments = stripJsonComments;

package/tsconfig.json

@@ -17,7 +17,7 @@
     // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
     // "sourceMap": true,                     /* Generates corresponding '.map' file. */
     // "outFile": "./",                       /* Concatenate and emit output to single file. */
-    // "outDir": "./lib",                        /* Redirect output structure to the directory. */
+    "outDir": "./lib",                        /* Redirect output structure to the directory. */
     // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
     // "composite": true,                     /* Enable project compilation */
     // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
@@ -72,7 +72,11 @@
 
     /* Advanced Options */
     "skipLibCheck": true,                     /* Skip type checking of declaration files. */
-    "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
+    "forceConsistentCasingInFileNames": true,  /* Disallow inconsistently-cased references to the same file. */
+    "plugins": [
+      { "transform": "typescript-is/lib/transform-inline/transformer" },
+      { "transform": "typescript-transform-paths" }
+    ]
   },
   "include": ["src"]
 }