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

package/lib/analyses/ControllerAnalyzer.js

@@ -0,0 +1,191 @@
+"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 __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 __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.ControllerAnalyzer = void 0;
+var NodePath = __importStar(require("path"));
+var tsc = __importStar(require("typescript"));
+var HashMap_1 = require("tstl/container/HashMap");
+var GenericAnalyzer_1 = require("./GenericAnalyzer");
+var ImportAnalyzer_1 = require("./ImportAnalyzer");
+var ControllerAnalyzer;
+(function (ControllerAnalyzer) {
+    function analyze(checker, sourceFile, controller) {
+        // FIND CONTROLLER CLASS
+        var ret = [];
+        tsc.forEachChild(sourceFile, function (node) {
+            var _a;
+            if (tsc.isClassDeclaration(node) && ((_a = node.name) === null || _a === void 0 ? void 0 : _a.escapedText) === controller.name) {
+                // ANALYZE THE CONTROLLER
+                ret.push.apply(ret, __spreadArray([], __read(_Analyze_controller(checker, controller, node)), false));
+                return;
+            }
+        });
+        return ret;
+    }
+    ControllerAnalyzer.analyze = analyze;
+    /* ---------------------------------------------------------
+        CLASS
+    --------------------------------------------------------- */
+    function _Analyze_controller(checker, controller, classNode) {
+        var e_1, _a, e_2, _b;
+        var ret = [];
+        var classType = checker.getTypeAtLocation(classNode);
+        var genericDict = GenericAnalyzer_1.GenericAnalyzer.analyze(checker, classNode);
+        try {
+            for (var _c = __values(classType.getProperties()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var property = _d.value;
+                if (property.declarations) {
+                    var _loop_1 = function (declaration) {
+                        // TARGET ONLY METHOD
+                        if (!tsc.isMethodDeclaration(declaration))
+                            return "continue";
+                        // IT MUST BE
+                        var identifier = declaration.name;
+                        if (!tsc.isIdentifier(identifier))
+                            return "continue";
+                        // ANALYZED WITH THE REFLECTED-FUNCTION
+                        var func = controller.functions.find(function (f) { return f.name === identifier.escapedText; });
+                        if (func !== undefined)
+                            ret.push(_Analyze_function(checker, controller, genericDict, func, declaration));
+                    };
+                    try {
+                        for (var _e = (e_2 = void 0, __values(property.declarations)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var declaration = _f.value;
+                            _loop_1(declaration);
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return ret;
+    }
+    /* ---------------------------------------------------------
+        FUNCTION
+    --------------------------------------------------------- */
+    function _Analyze_function(checker, controller, genericDict, func, declaration) {
+        // PREPARE ASSETS
+        var signature = checker.getSignatureFromDeclaration(declaration);
+        if (signature === undefined)
+            throw new Error("Error on ControllerAnalyzer._Analyze_function(): unable to get the ignature from the ".concat(controller.name, ".").concat(func.name, "()."));
+        var importDict = new HashMap_1.HashMap();
+        // EXPLORE CHILDREN TYPES
+        var parameters = func.parameters.map(function (param) { return _Analyze_parameter(checker, genericDict, importDict, controller, func.name, param, declaration.parameters[param.index]); });
+        var output = ImportAnalyzer_1.ImportAnalyzer.analyze(checker, genericDict, importDict, checker.getReturnTypeOfSignature(signature));
+        var imports = importDict.toJSON().map(function (pair) { return [pair.first, pair.second.toJSON()]; });
+        // CONFIGURE PATH
+        var path = _Normalize_path(NodePath.join(controller.path, func.path)
+            .split("\\")
+            .join("/"));
+        // RETURNS
+        return __assign(__assign({}, func), { path: path, parameters: parameters, output: output, imports: imports, symbol: "".concat(controller.name, ".").concat(func.name, "()"), comments: signature.getDocumentationComment(undefined), tags: signature.getJsDocTags() });
+    }
+    function _Normalize_path(path) {
+        if (path[0] !== "/")
+            path = "/" + path;
+        if (path[path.length - 1] === "/" && path !== "/")
+            path = path.substr(0, path.length - 1);
+        return path;
+    }
+    /* ---------------------------------------------------------
+        PARAMETER
+    --------------------------------------------------------- */
+    function _Analyze_parameter(checker, genericDict, importDict, controller, funcName, param, declaration) {
+        var symbol = checker.getSymbolAtLocation(declaration.name);
+        var type = checker.getTypeOfSymbolAtLocation(symbol, declaration);
+        var name = symbol.getEscapedName().toString();
+        // VALIDATE PARAMETERS
+        if ((param.category === "query" || param.category === "body") && param.field !== undefined)
+            throw new Error("Error on ".concat(controller.name, ".").concat(funcName, "(): parameter ").concat(name, " is specifying a field ").concat(param.field, " of the request ").concat(param.category, " message, however, Nestia does not support the field specialization for the request ").concat(param.category, " message. Erase the ").concat(controller.name, ".").concat(funcName, "()#").concat(name, " parameter and re-define a new decorator accepting full structured message."));
+        return {
+            name: name,
+            category: param.category,
+            field: param.field,
+            encrypted: param.encrypted,
+            type: ImportAnalyzer_1.ImportAnalyzer.analyze(checker, genericDict, importDict, type)
+        };
+    }
+})(ControllerAnalyzer = exports.ControllerAnalyzer || (exports.ControllerAnalyzer = {}));
+//# sourceMappingURL=ControllerAnalyzer.js.map

package/lib/analyses/GenericAnalyzer.d.ts

@@ -0,0 +1,6 @@
+import * as tsc from "typescript";
+export declare namespace GenericAnalyzer {
+    type Dictionary = WeakMap<tsc.Type, tsc.Type>;
+    function analyze(checker: tsc.TypeChecker, classNode: tsc.ClassDeclaration): Dictionary;
+}
+//# sourceMappingURL=GenericAnalyzer.d.ts.map

package/lib/analyses/GenericAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenericAnalyzer.d.ts","sourceRoot":"","sources":["../../src/analyses/GenericAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,YAAY,CAAC;AAElC,yBAAiB,eAAe,CAChC;IACI,KAAY,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IAErD,SAAgB,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,WAAW,EAAE,SAAS,EAAE,GAAG,CAAC,gBAAgB,GAAG,UAAU,CAK7F;CAwCJ"}

package/lib/analyses/GenericAnalyzer.js

@@ -0,0 +1,100 @@
+"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.GenericAnalyzer = void 0;
+var tsc = __importStar(require("typescript"));
+var GenericAnalyzer;
+(function (GenericAnalyzer) {
+    function analyze(checker, classNode) {
+        var dict = new WeakMap();
+        explore(checker, dict, classNode);
+        return dict;
+    }
+    GenericAnalyzer.analyze = analyze;
+    function explore(checker, dict, classNode) {
+        var e_1, _a, e_2, _b;
+        if (classNode.heritageClauses === undefined)
+            return;
+        try {
+            for (var _c = __values(classNode.heritageClauses), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var heritage = _d.value;
+                var _loop_1 = function (hType) {
+                    // MUST BE CLASS
+                    var expression = checker.getTypeAtLocation(hType.expression);
+                    var superNode = expression.symbol.getDeclarations()[0];
+                    if (!tsc.isClassDeclaration(superNode))
+                        return "continue";
+                    // SPECIFY GENERICS
+                    var usages = if_undefined_array(hType.typeArguments);
+                    var parameters = if_undefined_array(superNode.typeParameters);
+                    parameters.forEach(function (param, index) {
+                        var paramType = checker.getTypeAtLocation(param);
+                        var usageType = (usages[index] !== undefined)
+                            ? checker.getTypeAtLocation(usages[index])
+                            : checker.getTypeAtLocation(param.default);
+                        dict.set(paramType, usageType);
+                    });
+                    // RECUSRIVE EXPLORATION
+                    explore(checker, dict, superNode);
+                };
+                try {
+                    for (var _e = (e_2 = void 0, __values(heritage.types)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var hType = _f.value;
+                        _loop_1(hType);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    function if_undefined_array(array) {
+        return array !== undefined ? array : [];
+    }
+})(GenericAnalyzer = exports.GenericAnalyzer || (exports.GenericAnalyzer = {}));
+//# sourceMappingURL=GenericAnalyzer.js.map

package/lib/analyses/ImportAnalyzer.d.ts

@@ -0,0 +1,14 @@
+import tsc from "typescript";
+import { HashMap } from "tstl/container/HashMap";
+import { HashSet } from "tstl/container/HashSet";
+import { GenericAnalyzer } from "./GenericAnalyzer";
+import { IType } from "../structures/IType";
+export declare namespace ImportAnalyzer {
+    interface IOutput {
+        features: [string, string[]][];
+        alias: string;
+    }
+    type Dictionary = HashMap<string, HashSet<string>>;
+    function analyze(checker: tsc.TypeChecker, genericDict: GenericAnalyzer.Dictionary, importDict: Dictionary, type: tsc.Type): IType;
+}
+//# sourceMappingURL=ImportAnalyzer.d.ts.map

package/lib/analyses/ImportAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportAnalyzer.d.ts","sourceRoot":"","sources":["../../src/analyses/ImportAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,YAAY,CAAC;AAC7B,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEjD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C,yBAAiB,cAAc,CAC/B;IACI,UAAiB,OAAO;QAEpB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QAC/B,KAAK,EAAE,MAAM,CAAC;KACjB;IAED,KAAY,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAE1D,SAAgB,OAAO,CAEf,OAAO,EAAE,GAAG,CAAC,WAAW,EACxB,WAAW,EAAE,eAAe,CAAC,UAAU,EACvC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,GAAG,CAAC,IAAI,GACf,KAAK,CAMX;CAoHJ"}

package/lib/analyses/ImportAnalyzer.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportAnalyzer = void 0;
+var typescript_1 = __importDefault(require("typescript"));
+var HashSet_1 = require("tstl/container/HashSet");
+var ImportAnalyzer;
+(function (ImportAnalyzer) {
+    function analyze(checker, genericDict, importDict, type) {
+        return {
+            metadata: get_type(checker, type),
+            escapedText: explore_escaped_name(checker, genericDict, importDict, type)
+        };
+    }
+    ImportAnalyzer.analyze = analyze;
+    /* ---------------------------------------------------------
+        TYPE
+    --------------------------------------------------------- */
+    function get_type(checker, type) {
+        var symbol = type.getSymbol() || type.aliasSymbol;
+        return symbol && get_name(symbol) === "Promise"
+            ? escape_promise(checker, type)
+            : type;
+    }
+    function escape_promise(checker, type) {
+        var generic = checker.getTypeArguments(type);
+        if (generic.length !== 1)
+            throw new Error("Error on ImportAnalyzer.analyze(): invalid promise type.");
+        return generic[0];
+    }
+    function get_name(symbol) {
+        return explore_name(symbol.escapedName.toString(), symbol.getDeclarations()[0].parent);
+    }
+    /* ---------------------------------------------------------
+        ESCAPED TEXT WITH IMPORT STATEMENTS
+    --------------------------------------------------------- */
+    function explore_escaped_name(checker, genericDict, importDict, type) {
+        //----
+        // CONDITIONAL BRANCHES
+        //----
+        // DECOMPOSE GENERIC ARGUMENT
+        while (genericDict.has(type) === true)
+            type = genericDict.get(type);
+        // PRIMITIVE
+        var symbol = type.getSymbol() || type.aliasSymbol;
+        if (symbol === undefined)
+            return checker.typeToString(type, undefined, undefined);
+        // UNION OR INTERSECT
+        else if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
+            var joiner = type.isIntersection() ? " & " : " | ";
+            return type.types.map(function (child) { return explore_escaped_name(checker, genericDict, importDict, child); }).join(joiner);
+        }
+        //----
+        // SPECIALIZATION
+        //----
+        var name = get_name(symbol);
+        var sourceFile = symbol.declarations[0].getSourceFile();
+        if (sourceFile.fileName.indexOf("typescript/lib") === -1) {
+            var set = importDict.take(sourceFile.fileName, function () { return new HashSet_1.HashSet(); });
+            set.insert(name.split(".")[0]);
+        }
+        // CHECK GENERIC
+        var generic = checker.getTypeArguments(type);
+        if (generic.length)
+            return name === "Promise"
+                ? explore_escaped_name(checker, genericDict, importDict, generic[0])
+                : "".concat(name, "<").concat(generic.map(function (child) { return explore_escaped_name(checker, genericDict, importDict, child); }).join(", "), ">");
+        else
+            return name;
+    }
+    function explore_name(name, decl) {
+        return typescript_1.default.isModuleBlock(decl)
+            ? explore_name("".concat(decl.parent.name.getText(), ".").concat(name), decl.parent.parent)
+            : name;
+    }
+})(ImportAnalyzer = exports.ImportAnalyzer || (exports.ImportAnalyzer = {}));
+//# sourceMappingURL=ImportAnalyzer.js.map

package/lib/analyses/ReflectAnalyzer.d.ts

@@ -0,0 +1,5 @@
+import { IController } from "../structures/IController";
+export declare namespace ReflectAnalyzer {
+    function analyze(unique: WeakSet<any>, file: string): Promise<IController[]>;
+}
+//# sourceMappingURL=ReflectAnalyzer.d.ts.map

package/lib/analyses/ReflectAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReflectAnalyzer.d.ts","sourceRoot":"","sources":["../../src/analyses/ReflectAnalyzer.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAQxD,yBAAiB,eAAe,CAChC;IACI,SAAsB,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAiBxF;CAsMJ"}