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

package/lib/utils/ImportDictionary.js

@@ -0,0 +1,83 @@
+"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;
+};
+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.ImportDictionary = void 0;
+var path = __importStar(require("path"));
+var HashMap_1 = require("tstl/container/HashMap");
+var HashSet_1 = require("tstl/container/HashSet");
+var Pair_1 = require("tstl/utility/Pair");
+var ImportDictionary = /** @class */ (function () {
+    function ImportDictionary() {
+        this.dict_ = new HashMap_1.HashMap();
+    }
+    ImportDictionary.prototype.empty = function () {
+        return this.dict_.empty();
+    };
+    ImportDictionary.prototype.emplace = function (file, realistic, instance) {
+        if (file.substr(-5) === ".d.ts")
+            file = file.substr(0, file.length - 5);
+        else if (file.substr(-3) === ".ts")
+            file = file.substr(0, file.length - 3);
+        else
+            throw new Error("Error on ImportDictionary.emplace(): extension of the target file \"".concat(file, "\" is not \"ts\"."));
+        var pair = this.dict_.take(file, function () { return new Pair_1.Pair(realistic, new HashSet_1.HashSet()); });
+        pair.second.insert(instance);
+    };
+    ImportDictionary.prototype.toScript = function (outDir) {
+        var e_1, _a;
+        var statements = [];
+        try {
+            for (var _b = __values(this.dict_), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var it = _c.value;
+                var file = path.relative(outDir, it.first).split("\\").join("/");
+                var realistic = it.second.first;
+                var instances = it.second.second.toJSON();
+                statements.push("import ".concat(!realistic ? "type " : "", "{ ").concat(instances.join(", "), " } from \"./").concat(file, "\";"));
+            }
+        }
+        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; }
+        }
+        return statements.join("\n");
+    };
+    return ImportDictionary;
+}());
+exports.ImportDictionary = ImportDictionary;
+//# sourceMappingURL=ImportDictionary.js.map

package/lib/utils/MapUtil.d.ts

@@ -0,0 +1,4 @@
+export declare namespace MapUtil {
+    function take<Key, T>(dict: Map<Key, T>, key: Key, generator: () => T): T;
+}
+//# sourceMappingURL=MapUtil.d.ts.map

package/lib/utils/MapUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapUtil.d.ts","sourceRoot":"","sources":["../../src/utils/MapUtil.ts"],"names":[],"mappings":"AAAA,yBAAiB,OAAO,CACxB;IACI,SAAgB,IAAI,CAAC,GAAG,EAAE,CAAC,EACtB,IAAI,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,CASvD;CACJ"}

package/lib/utils/MapUtil.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapUtil = void 0;
+var MapUtil;
+(function (MapUtil) {
+    function take(dict, key, generator) {
+        var oldbie = dict.get(key);
+        if (oldbie)
+            return oldbie;
+        var value = generator();
+        dict.set(key, value);
+        return value;
+    }
+    MapUtil.take = take;
+})(MapUtil = exports.MapUtil || (exports.MapUtil = {}));
+//# sourceMappingURL=MapUtil.js.map

package/lib/utils/StringUtil.d.ts

@@ -0,0 +1,4 @@
+export declare namespace StringUtil {
+    function betweens(str: string, start: string, end: string): string[];
+}
+//# sourceMappingURL=StringUtil.d.ts.map

package/lib/utils/StringUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringUtil.d.ts","sourceRoot":"","sources":["../../src/utils/StringUtil.ts"],"names":[],"mappings":"AAAA,yBAAiB,UAAU,CAC3B;IACI,SAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAM1E;CACJ"}

package/lib/utils/StringUtil.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringUtil = void 0;
+var StringUtil;
+(function (StringUtil) {
+    function betweens(str, start, end) {
+        var ret = str.split(start);
+        ret.splice(0, 1);
+        return ret.map(function (str) { return str.split(end)[0]; });
+    }
+    StringUtil.betweens = betweens;
+})(StringUtil = exports.StringUtil || (exports.StringUtil = {}));
+//# sourceMappingURL=StringUtil.js.map

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "nestia",
-  "version": "2.1.0-dev.20220414",
+  "version": "2.1.0-dev.20220430",
   "description": "Automatic SDK and Document generator for the NestJS",
-  "main": "src/index.ts",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
   "bin": {
-    "nestia": "./src/bin/nestia.ts"
+    "nestia": "./lib/executable/nestia.js"
   },
   "scripts": {
-    "dev": "tsc --watch",
-    "test": "ts-node test/index"
+    "build": "rimraf lib && ttsc",
+    "dev": "npm run build -- --watch",
+    "test": "node lib/test"
   },
   "repository": {
     "type": "git",
@@ -28,21 +30,26 @@
   },
   "homepage": "https://github.com/samchon/nestia#readme",
   "dependencies": {
-    "@types/cli": "^0.11.19",
-    "@types/glob": "^7.2.0",
-    "@types/node": "^17.0.23",
-    "@types/reflect-metadata": "^0.1.0",
     "cli": "^1.0.1",
     "del": "^6.0.0",
     "glob": "^7.2.0",
+    "jsonc-simple-parser": "^2.2.1",
+    "nestia-fetcher": "^2.0.1",
+    "tgrid": "^0.8.6",
     "ts-node": "^10.7.0",
-    "tstl": "^2.5.3",
+    "tsconfig-paths": "^3.14.1",
+    "tstl": "^2.5.5",
     "ttypescript": "^1.5.13",
     "typescript": "^4.6.3",
     "typescript-is": "^0.19.0",
+    "typescript-json": "^2.0.5",
     "typescript-transform-paths": "^3.3.1"
   },
   "devDependencies": {
+    "@types/cli": "^0.11.19",
+    "@types/glob": "^7.2.0",
+    "@types/node": "^17.0.23",
+    "@types/reflect-metadata": "^0.1.0",
     "nestia-helper": "^2.0.0",
     "rimraf": "^3.0.2"
   }

package/src/IConfiguration.ts

@@ -1,17 +0,0 @@
-import * as tsc from "typescript";
-
-export interface IConfiguration
-{
-    input: string | string[] | IConfiguration.IInput;
-    output: string;
-    compilerOptions?: tsc.CompilerOptions;
-    assert?: boolean;
-}
-export namespace IConfiguration
-{
-    export interface IInput
-    {
-        include: string[];
-        exclude?: string[];
-    }
-}

package/src/NestiaApplication.ts

@@ -1,96 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as tsc from "typescript";
-import { Pair } from "tstl/utility/Pair";
-import { Singleton } from "tstl/thread/Singleton";
-
-import { ControllerAnalyzer } from "./analyses/ControllerAnalyzer";
-import { ReflectAnalyzer } from "./analyses/ReflectAnalyzer";
-import { SourceFinder } from "./analyses/SourceFinder";
-import { SdkGenerator } from "./generates/SdkGenerator";
-
-import { IConfiguration } from "./IConfiguration";
-import { IController } from "./structures/IController";
-import { IRoute } from "./structures/IRoute";
-import { ArrayUtil } from "./utils/ArrayUtil";
-
-export class NestiaApplication
-{
-    private readonly config_: IConfiguration;
-    private readonly bundle_checker_: Singleton<Promise<(str: string) => boolean>>;
-
-    public constructor(config: IConfiguration)
-    {
-        this.config_ = config;
-        this.bundle_checker_ = new Singleton(async () =>
-        {
-            const bundles: string[] = await fs.promises.readdir(`${__dirname}${path.sep}bundle`);
-            const tuples: Pair<string, boolean>[] = await ArrayUtil.asyncMap(bundles, async file =>
-            {
-                const relative: string = `${this.config_.output}${path.sep}${file}`;
-                const stats: fs.Stats = await fs.promises.stat(`${__dirname}${path.sep}bundle${path.sep}${file}`);
-
-                return new Pair(relative, stats.isDirectory());
-            });
-
-            return (file: string): boolean =>
-            {
-                for (const it of tuples)
-                    if (it.second === false && file === it.first)
-                        return true;
-                    else if (it.second === true && file.indexOf(it.first) === 0)
-                        return true;
-                return false;
-            };
-        });
-    }
-
-    public async generate(): Promise<void>
-    {
-        // LOAD CONTROLLER FILES
-        const input: IConfiguration.IInput = this.config_.input instanceof Array
-            ? { include: this.config_.input }
-            : typeof this.config_.input === "string"
-                ? { include: [ this.config_.input ] }
-                : this.config_.input;
-        const fileList: string[] = await ArrayUtil.asyncFilter
-        (
-            await SourceFinder.find(input),
-            file => this.is_not_excluded(file)
-        );
-
-        // ANALYZE REFLECTS
-        const unique: WeakSet<any> = new WeakSet();
-        const controllerList: IController[] = [];
-        
-        for (const file of fileList)
-            controllerList.push(...await ReflectAnalyzer.analyze(unique, file));
-
-        // ANALYZE TYPESCRIPT CODE
-        const program: tsc.Program = tsc.createProgram
-        (
-            controllerList.map(c => c.file), 
-            this.config_.compilerOptions || {}
-        );
-        const checker: tsc.TypeChecker = program.getTypeChecker();
-
-        const routeList: IRoute[] = [];
-        for (const controller of controllerList)
-        {
-            const sourceFile: tsc.SourceFile | undefined = program.getSourceFile(controller.file);
-            if (sourceFile === undefined)
-                continue;
-
-            routeList.push(...ControllerAnalyzer.analyze(checker, sourceFile, controller));
-        }
-
-        // DO GENERATE
-        await SdkGenerator.generate(this.config_, routeList);
-    }
-
-    private async is_not_excluded(file: string): Promise<boolean>
-    {
-        return file.indexOf(`${this.config_.output}${path.sep}functional`) === -1
-            && (await this.bundle_checker_.get())(file) === false;
-    }
-}

package/src/analyses/ControllerAnalyzer.ts

@@ -1,154 +0,0 @@
-import * as NodePath from "path";
-import * as tsc from "typescript";
-import { HashMap } from "tstl/container/HashMap";
-
-import { IController } from "../structures/IController";
-import { IRoute } from "../structures/IRoute";
-
-import { GenericAnalyzer } from "./GenericAnalyzer";
-import { ImportAnalyzer } from "./ImportAnalyzer";
-
-export namespace ControllerAnalyzer
-{
-    export function analyze(checker: tsc.TypeChecker, sourceFile: tsc.SourceFile, controller: IController): IRoute[]
-    {
-        // FIND CONTROLLER CLASS
-        const ret: IRoute[] = [];
-        tsc.forEachChild(sourceFile, node =>
-        {
-            if (tsc.isClassDeclaration(node) && node.name?.escapedText === controller.name)
-            {
-                // ANALYZE THE CONTROLLER
-                ret.push(..._Analyze_controller(checker, controller, node));
-                return;
-            }
-        });
-        return ret;
-    }
-
-    /* ---------------------------------------------------------
-        CLASS
-    --------------------------------------------------------- */
-    function _Analyze_controller
-        (
-            checker: tsc.TypeChecker, 
-            controller: IController, 
-            classNode: tsc.ClassDeclaration
-        ): IRoute[]
-    {
-        const ret: IRoute[] = [];
-        const classType: tsc.InterfaceType = checker.getTypeAtLocation(classNode) as tsc.InterfaceType;
-        const genericDict: GenericAnalyzer.Dictionary = GenericAnalyzer.analyze(checker, classNode);
-
-        for (const property of classType.getProperties())
-            if (property.declarations)
-                for (const declaration of property.declarations)
-                {
-                    // TARGET ONLY METHOD
-                    if (!tsc.isMethodDeclaration(declaration))
-                        continue;
-                    
-                    // IT MUST BE
-                    const identifier = declaration.name;
-                    if (!tsc.isIdentifier(identifier))
-                        continue;
-                
-                    // ANALYZED WITH THE REFLECTED-FUNCTION
-                    const func: IController.IFunction | undefined = controller.functions.find(f => f.name === identifier.escapedText);
-                    if (func !== undefined)
-                        ret.push(_Analyze_function(checker, controller, genericDict, func, declaration));
-                }
-        return ret;
-    }
-
-    /* ---------------------------------------------------------
-        FUNCTION
-    --------------------------------------------------------- */
-    function _Analyze_function
-        (
-            checker: tsc.TypeChecker, 
-            controller: IController, 
-            genericDict: GenericAnalyzer.Dictionary,
-            func: IController.IFunction, 
-            declaration: tsc.MethodDeclaration
-        ): IRoute
-    {
-        // PREPARE ASSETS
-        const signature: tsc.Signature | undefined = checker.getSignatureFromDeclaration(declaration);
-        if (signature === undefined)
-            throw new Error(`Error on ControllerAnalyzer._Analyze_function(): unable to get the ignature from the ${controller.name}.${func.name}().`);
-        
-        const importDict: ImportAnalyzer.Dictionary = new HashMap();
-
-        // EXPLORE CHILDREN TYPES
-        const parameters: IRoute.IParameter[] = func.parameters.map(param => _Analyze_parameter
-        (
-            checker, 
-            genericDict, 
-            importDict, 
-            controller,
-            func.name,
-            param, 
-            declaration.parameters[param.index]
-        ));
-        const output: string = ImportAnalyzer.analyze
-        (
-            checker,
-            genericDict,
-            importDict,
-            checker.getReturnTypeOfSignature(signature),
-        );
-        const imports: [string, string[]][] = importDict.toJSON().map(pair => [pair.first, pair.second.toJSON()]);
-
-        // CONFIGURE PATH
-        let path: string = NodePath.join(controller.path, func.path).split("\\").join("/");
-        if (path[0] !== "/")
-            path = "/" + path;
-        if (path[path.length - 1] === "/" && path !== "/")
-            path = path.substr(0, path.length - 1);
-
-        // RETURNS
-        return {
-            ...func,
-            path,
-            parameters,
-            output,
-            imports,
-
-            symbol: `${controller.name}.${func.name}()`,
-            comments: signature.getDocumentationComment(undefined),
-            tags: signature.getJsDocTags()
-        };
-    }
-
-    /* ---------------------------------------------------------
-        PARAMETER
-    --------------------------------------------------------- */
-    function _Analyze_parameter
-        (
-            checker: tsc.TypeChecker, 
-            genericDict: GenericAnalyzer.Dictionary,
-            importDict: ImportAnalyzer.Dictionary,
-            controller: IController,
-            funcName: string,
-            param: IController.IParameter, 
-            declaration: tsc.ParameterDeclaration
-        ): IRoute.IParameter
-    {
-        const symbol: tsc.Symbol = checker.getSymbolAtLocation(declaration.name)!;
-        const type: tsc.Type = checker.getTypeOfSymbolAtLocation(symbol, declaration);
-        const name: string = symbol.getEscapedName().toString();
-
-        // VALIDATE PARAMETERS
-        if ((param.category === "query" || param.category === "body") && param.field !== undefined)
-            throw new Error(`Error on ${controller.name}.${funcName}(): parameter ${name} is specifying a field ${param.field} of the request ${param.category} message, however, Nestia does not support the field specialization for the request ${param.category} message. Erase the ${controller.name}.${funcName}()#${name} parameter and re-define a new decorator accepting full structured message.`);
-
-        return {
-            name,
-            category: param.category,
-            field: param.field,
-            encrypted: param.encrypted,
-            type: ImportAnalyzer.analyze(checker, genericDict, importDict, type)
-        };
-    }
-}

package/src/analyses/GenericAnalyzer.ts

@@ -1,52 +0,0 @@
-import * as tsc from "typescript";
-
-export namespace GenericAnalyzer
-{
-    export type Dictionary = WeakMap<tsc.Type, tsc.Type>;
-
-    export function analyze(checker: tsc.TypeChecker, classNode: tsc.ClassDeclaration): Dictionary
-    {
-        const dict: Dictionary = new WeakMap();
-        explore(checker, dict, classNode);
-        return dict;
-    }
-
-    function explore(checker: tsc.TypeChecker, dict: Dictionary, classNode: tsc.ClassDeclaration): void
-    {
-        if (classNode.heritageClauses === undefined)
-            return;
-
-        for (const heritage of classNode.heritageClauses)
-            for (const hType of heritage.types)
-            {
-                // MUST BE CLASS
-                const expression: tsc.Type = checker.getTypeAtLocation(hType.expression);
-                const superNode: tsc.Declaration = expression.symbol.getDeclarations()![0];
-
-                if (!tsc.isClassDeclaration(superNode))
-                    continue;
-
-                // SPECIFY GENERICS
-                const usages: ReadonlyArray<tsc.TypeNode> = if_undefined_array(hType.typeArguments);                
-                const parameters: ReadonlyArray<tsc.TypeParameterDeclaration> = if_undefined_array(superNode.typeParameters);
-
-                parameters.forEach((param, index) =>
-                {
-                    const paramType: tsc.Type = checker.getTypeAtLocation(param);
-                    const usageType: tsc.Type = (usages[index] !== undefined)
-                        ? checker.getTypeAtLocation(usages[index])
-                        : checker.getTypeAtLocation(param.default!);
-
-                    dict.set(paramType, usageType);
-                });
-
-                // RECUSRIVE EXPLORATION
-                explore(checker, dict, superNode);
-            }
-    }
-
-    function if_undefined_array<T>(array: ReadonlyArray<T> | undefined): ReadonlyArray<T>
-    {
-        return array !== undefined ? array : [];
-    }
-}

package/src/analyses/ImportAnalyzer.ts

@@ -1,93 +0,0 @@
-import * as tsc from "typescript";
-
-import { HashMap } from "tstl/container/HashMap";
-import { HashSet } from "tstl/container/HashSet";
-import { GenericAnalyzer } from "./GenericAnalyzer";
-
-export namespace ImportAnalyzer
-{
-    export interface IOutput
-    {
-        features: [string, string[]][];
-        alias: string;
-    }
-
-    export type Dictionary = HashMap<string, HashSet<string>>;
-
-    export function analyze
-        (
-            checker: tsc.TypeChecker, 
-            genericDict: GenericAnalyzer.Dictionary, 
-            importDict: Dictionary, 
-            type: tsc.Type
-        ): string
-    {
-        return explore(checker, genericDict, importDict, type);
-    }
-
-    function explore
-        (
-            checker: tsc.TypeChecker, 
-            genericDict: GenericAnalyzer.Dictionary, 
-            importDict: Dictionary, 
-            type: tsc.Type
-        ): string
-    {
-        //----
-        // CONDITIONAL BRANCHES
-        //----
-        // DECOMPOSE GENERIC ARGUMENT
-        while (genericDict.has(type) === true)
-            type = genericDict.get(type)!;
-
-        // PRIMITIVE
-        const symbol: tsc.Symbol | undefined = type.getSymbol() || type.aliasSymbol;
-        if (symbol === undefined)
-            return checker.typeToString(type, undefined, undefined);
-        
-        // UNION OR INTERSECT
-        else if (type.aliasSymbol === undefined && type.isUnionOrIntersection())
-        {
-            const joiner: string = type.isIntersection() ? " & " : " | ";
-            return type.types.map(child => explore(checker, genericDict, importDict, child)).join(joiner);
-        }
-
-        //----
-        // SPECIALIZATION
-        //----
-        const name: string = get_name(symbol);
-        const sourceFile: tsc.SourceFile = symbol.declarations![0].getSourceFile();
-
-        if (sourceFile.fileName.indexOf("typescript/lib") === -1)
-        {
-            let it: HashMap.Iterator<string, HashSet<string>> = importDict.find(sourceFile.fileName);
-            if (it.equals(importDict.end()) === true)
-                it = importDict.emplace(sourceFile.fileName, new HashSet()).first;
-            it.second.insert(name.split(".")[0]);
-        }
-
-        // CHECK GENERIC
-        const generic: readonly tsc.Type[] = checker.getTypeArguments(type as tsc.TypeReference);
-        if (generic.length)
-        {
-            return name === "Promise"
-                ? explore(checker, genericDict, importDict, generic[0])
-                : `${name}<${generic.map(child => explore(checker, genericDict, importDict, child)).join(", ")}>`;
-        }
-        else
-            return name;
-    }
-
-    function get_name(symbol: tsc.Symbol): string
-    {
-        let name: string = symbol.escapedName.toString();
-        let decl: tsc.Node = symbol.getDeclarations()![0].parent;
-
-        while (tsc.isModuleBlock(decl))
-        {
-            name = `${decl.parent.name.getText()}.${name}`;
-            decl = decl.parent.parent;
-        }
-        return name;
-    }
-}