@lcap/nasl 2.20.1-beta.2 → 2.21.0-beta.1

package/src/generator/dist/permission.js

@@ -0,0 +1,405 @@
+"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 __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+exports.genPermissionData = void 0;
+var concepts_1 = require("../concepts");
+var process2LogicNamespace_1 = require("../server/process2LogicNamespace");
+function isReadOnly(logic) {
+    var _a;
+    return !!logic.module
+        || ((_a = logic.parentNode) === null || _a === void 0 ? void 0 : _a.concept) === 'Namespace'
+        || logic.parentKey === 'readonly'; // process logic
+}
+var cache = new Map();
+var useCache = false;
+function findUsage(logic) {
+    return __awaiter(this, void 0, void 0, function () {
+        var res, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (useCache && cache.has(logic))
+                        return [2 /*return*/, cache.get(logic)];
+                    if (!isReadOnly(logic)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, logic.findReadOnlyLogicUsage()];
+                case 1:
+                    _a = _b.sent();
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, logic.findUsage()];
+                case 3:
+                    _a = _b.sent();
+                    _b.label = 4;
+                case 4:
+                    res = _a;
+                    if (useCache)
+                        cache.set(logic, res);
+                    return [2 /*return*/, res];
+            }
+        });
+    });
+}
+function openCache() {
+    useCache = true;
+    cache.clear();
+}
+function closeCache() {
+    useCache = false;
+    cache.clear();
+}
+function findViewLogicReferences(logic, vis) {
+    if (vis === void 0) { vis = new Set(); }
+    return __awaiter(this, void 0, void 0, function () {
+        function dfs(usage) {
+            return __awaiter(this, void 0, void 0, function () {
+                var logic_1, _i, _a, child;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!(usage.node instanceof concepts_1.CallLogic)) return [3 /*break*/, 2];
+                            logic_1 = usage.node.logic;
+                            if (!(!vis.has(logic_1) && logic_1)) return [3 /*break*/, 2];
+                            vis.add(logic_1);
+                            return [4 /*yield*/, findViewLogicReferences(logic_1, vis)];
+                        case 1:
+                            _b.sent();
+                            _b.label = 2;
+                        case 2:
+                            if (!usage.children) return [3 /*break*/, 6];
+                            _i = 0, _a = usage.children;
+                            _b.label = 3;
+                        case 3:
+                            if (!(_i < _a.length)) return [3 /*break*/, 6];
+                            child = _a[_i];
+                            return [4 /*yield*/, dfs(child)];
+                        case 4:
+                            _b.sent();
+                            _b.label = 5;
+                        case 5:
+                            _i++;
+                            return [3 /*break*/, 3];
+                        case 6: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        var usageMap, usages, _i, usages_1, usage;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, findUsage(logic)];
+                case 1:
+                    usageMap = _a.sent();
+                    usages = [];
+                    usageMap.forEach(function (usage, node) {
+                        if (node instanceof concepts_1.View)
+                            usages.push(usage);
+                    });
+                    _i = 0, usages_1 = usages;
+                    _a.label = 2;
+                case 2:
+                    if (!(_i < usages_1.length)) return [3 /*break*/, 5];
+                    usage = usages_1[_i];
+                    return [4 /*yield*/, dfs(usage)];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 5: return [2 /*return*/, Array.from(vis)];
+            }
+        });
+    });
+}
+function findUIReferences(logic) {
+    return __awaiter(this, void 0, void 0, function () {
+        function dfs(usage, parent) {
+            var _a;
+            if (parent === void 0) { parent = null; }
+            if (['logic1', 'logic2'].includes(logic.name)) {
+                console.log(usage.node);
+            }
+            if ((usage.node instanceof concepts_1.BindEvent || usage.node instanceof concepts_1.BindAttribute)
+                && (parent.node instanceof concepts_1.View || parent.node instanceof concepts_1.ViewElement))
+                res.push(parent.node);
+            (_a = usage.children) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {
+                dfs(child, usage);
+            });
+        }
+        var usageMap, usages, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, findUsage(logic)];
+                case 1:
+                    usageMap = _a.sent();
+                    usages = [];
+                    usageMap.forEach(function (usage, node) {
+                        if (node instanceof concepts_1.View)
+                            usages.push(usage);
+                    });
+                    res = [];
+                    usages.forEach(function (usage) {
+                        dfs(usage);
+                    });
+                    return [2 /*return*/, res];
+            }
+        });
+    });
+}
+function findResourcesOfUI(view) {
+    var res = [];
+    var node = view;
+    while (node) {
+        if (node instanceof concepts_1.View && node.auth)
+            res.push({
+                path: node.authPath,
+                type: 'page'
+            });
+        else if (node instanceof concepts_1.ViewElement) {
+            var hasAuth = node.bindDirectives.find(function (directive) { return directive.name === 'auth'; });
+            if (hasAuth)
+                res.push({
+                    path: node.authPath,
+                    type: 'component'
+                });
+        }
+        node = node.parentNode;
+    }
+    return res;
+}
+function optimizeResourceData(resources) {
+    var res = removeRedundantResourceData(resources);
+    res = removeRedundantResourceData2(res);
+    return res;
+}
+// [['b'], ['a' ,'b']] 只需要保留 [['b']]
+function removeRedundantResourceData(resources) {
+    var wm = new WeakMap();
+    for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
+        var resource = resources_1[_i];
+        var hash = resource.map(function (_a) {
+            var path = _a.path, type = _a.type;
+            return path + "_" + type;
+        })
+            .join();
+        wm.set(resource, hash);
+    }
+    resources.sort(function (a, b) { return wm.get(a).length - wm.get(b).length; });
+    var res = [];
+    var hashs = [];
+    ;
+    var _loop_1 = function (resource) {
+        var hash = wm.get(resource);
+        if (hashs.some(function (h) { return hash.endsWith(h); }))
+            return "continue";
+        res.push(resource);
+        hashs.push(hash);
+    };
+    for (var _a = 0, resources_2 = resources; _a < resources_2.length; _a++) {
+        var resource = resources_2[_a];
+        _loop_1(resource);
+    }
+    return res;
+}
+// 子页面有权限，父页面默认也有权限，所以不需要记录父页面权限；
+// 组件有权限，组件所在的页面默认也有权限，所以不需要记录页面权限
+function removeRedundantResourceData2(resources) {
+    return resources.map(function (resource) {
+        if (resource.length <= 1)
+            return resource;
+        if (resource[0].type === 'page')
+            return resource.slice(0, 1);
+        else if (resource[0].type === 'component')
+            return resource.filter(function (item) { return item.type === 'component'; });
+    });
+}
+function findResourcesOfLogic(logic, uploaders) {
+    return __awaiter(this, void 0, void 0, function () {
+        var logics, UIs, _i, logics_1, logic_2, _a, _b, service, res;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (['logic1', 'logic2'].includes(logic.name)) {
+                        debugger;
+                    }
+                    return [4 /*yield*/, findViewLogicReferences(logic)];
+                case 1:
+                    logics = _c.sent();
+                    logics.push(logic);
+                    UIs = [];
+                    _i = 0, logics_1 = logics;
+                    _c.label = 2;
+                case 2:
+                    if (!(_i < logics_1.length)) return [3 /*break*/, 5];
+                    logic_2 = logics_1[_i];
+                    _b = (_a = UIs).concat;
+                    return [4 /*yield*/, findUIReferences(logic_2)];
+                case 3:
+                    UIs = _b.apply(_a, [_c.sent()]);
+                    if (['logic1', 'logic2'].includes(logic_2.name)) {
+                        console.log(UIs);
+                    }
+                    _c.label = 4;
+                case 4:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 5:
+                    service = logic.toService();
+                    if (uploaders.has(service.url.path)) {
+                        UIs = UIs.concat(uploaders.get(service.url.path));
+                    }
+                    UIs = Array.from(new Set(UIs));
+                    res = UIs.map(function (ui) { return findResourcesOfUI(ui); });
+                    if (['logic1', 'logic2'].includes(logic.name)) {
+                        console.log(logic.name, UIs, res);
+                    }
+                    return [2 /*return*/, optimizeResourceData(res)];
+            }
+        });
+    });
+}
+function getAllLogics(app) {
+    var modules = [];
+    var entities = [];
+    var logics = [];
+    if (Array.isArray(app.dataSources)) {
+        app.dataSources.forEach(function (dataSource) {
+            if (Array.isArray(dataSource.entities)) {
+                entities.push.apply(entities, dataSource.entities);
+            }
+        });
+    }
+    app.logics && logics.push.apply(logics, app.logics);
+    app.dependencies && modules.push.apply(modules, app.dependencies);
+    app.interfaceDependencies && modules.push.apply(modules, app.interfaceDependencies);
+    modules.forEach(function (module) {
+        module.logics && logics.push.apply(logics, module.logics);
+        if (Array.isArray(module.dataSources)) {
+            module.dataSources.forEach(function (dataSource) {
+                if (Array.isArray(dataSource.entities)) {
+                    entities.push.apply(entities, dataSource.entities);
+                }
+            });
+        }
+    });
+    var allLogics = [];
+    if (Array.isArray(entities)) {
+        entities.forEach(function (entity) {
+            var ns = entity.ns;
+            if (Array.isArray(ns === null || ns === void 0 ? void 0 : ns.logics)) {
+                allLogics.push.apply(allLogics, ns.logics);
+            }
+        });
+    }
+    if (Array.isArray(logics)) {
+        allLogics.push.apply(allLogics, logics);
+    }
+    var processLogics = [];
+    var processTreeFragments = (app.processes || [])
+        .map(process2LogicNamespace_1.processToTreeFragment);
+    processTreeFragments.forEach(function (tree) {
+        processLogics.push.apply(processLogics, tree.logics);
+        tree.elements.forEach(function (element) {
+            processLogics.push.apply(processLogics, element.logics);
+        });
+    });
+    return {
+        logics: allLogics,
+        processLogics: processLogics
+    };
+}
+function findUploaders(app) {
+    var map = new Map();
+    app.traverseChildren(function (node) {
+        var _a;
+        if (node instanceof concepts_1.ViewElement && ((_a = node.tag) === null || _a === void 0 ? void 0 : _a.includes('uploader'))) {
+            var urlAttr = node.bindAttrs.find(function (item) { return item.name === 'url'; });
+            var url = urlAttr === null || urlAttr === void 0 ? void 0 : urlAttr.value;
+            if (url) {
+                if (!map.has(url))
+                    map.set(url, [node]);
+                else
+                    map.get(url).push(node);
+            }
+        }
+    });
+    return map;
+}
+function genPermissionData(app) {
+    return __awaiter(this, void 0, void 0, function () {
+        var logicPageResourceDtoList, _a, logics, processLogics, uploaders, _i, _b, logic, resources, service, key;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    // console.time('xxx');
+                    openCache();
+                    logicPageResourceDtoList = {};
+                    _a = getAllLogics(app), logics = _a.logics, processLogics = _a.processLogics;
+                    uploaders = findUploaders(app);
+                    _i = 0, _b = __spreadArrays(logics, processLogics);
+                    _c.label = 1;
+                case 1:
+                    if (!(_i < _b.length)) return [3 /*break*/, 4];
+                    logic = _b[_i];
+                    return [4 /*yield*/, findResourcesOfLogic(logic, uploaders)];
+                case 2:
+                    resources = _c.sent();
+                    if (resources.length === 0)
+                        return [3 /*break*/, 3];
+                    service = logics.includes(logic) ? logic.toService() : logic.toProcessService();
+                    key = service.url.path + ":" + service.url.method;
+                    logicPageResourceDtoList[key] = resources;
+                    _c.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4:
+                    closeCache();
+                    // console.timeEnd('xxx');
+                    return [2 /*return*/, logicPageResourceDtoList];
+            }
+        });
+    });
+}
+exports.genPermissionData = genPermissionData;

package/src/generator/genBundleFiles.ts

@@ -82,7 +82,7 @@ export function genBundleFiles(app: App, frontend: Frontend,
         let routePath = viewName;
         if (isRootView) {
             rootViewData.push({ name: viewName, title: view.title || viewName, isIndex: view.isIndex });
-            routePath = `${frontend.basePath}/${viewName}`;
+            routePath = `${frontend.prefixPath}/${viewName}`;
             if (!isViewAuth) {
                 if (viewName === 'notFound') {
                     defaultRoute = routePath;
@@ -133,15 +133,15 @@ export function genBundleFiles(app: App, frontend: Frontend,
         routes.push(route);
         if (view.isIndex) {
             routes.push({
-                path: frontend.basePath ? frontend.basePath : '/',
-                redirect: `'${frontend.basePath}/${view.name}'`,
+                path: frontend.prefixPath ? frontend.prefixPath : '/',
+                redirect: `'${frontend.prefixPath}/${view.name}'`,
             });
         }
     });
-    if (frontend.basePath) {
+    if (frontend.prefixPath) {
         routes.push({
             path: '/',
-            redirect: `'${frontend.basePath}'`,
+            redirect: `'${frontend.prefixPath}'`,
         });
     }
     const authResourcePathMap: any = {};
@@ -156,8 +156,8 @@ export function genBundleFiles(app: App, frontend: Frontend,
                     if (parentViewNode.concept === 'View') {
                         authResourcePathMap[parentViewNode.path] = true;
                     } else { // viewNode是根页面
-                        if (frontend.basePath) {
-                            authResourcePathMap[frontend.basePath] = true;
+                        if (frontend.prefixPath) {
+                            authResourcePathMap[frontend.prefixPath] = true;
                         }
                         authResourcePathMap['/'] = true;
                     }
@@ -222,8 +222,10 @@ export function genBundleFiles(app: App, frontend: Frontend,
             tenant: config.tenant,
             documentTitle: frontend.documentTitle,
             rootViewData,
-            basePath: frontend.basePath,
+            basePath: frontend.prefixPath,
             frontendName: frontend.name,
+            // 加上统一前缀
+            sysPrefixPath: app.sysPrefixPath,
         },
         dnsAddr: app.dnsAddr,
         devDnsAddr: config.devDnsAddr,

package/src/generator/genReleaseBody.ts

@@ -66,7 +66,7 @@ export async function genReleaseBody(app: App, {
         NaslAnnotatedJSON = await (app as any).naslServer.getNaslAnnotatedJSON(app, true);
     } catch (err) {
         console.error(err);
-        throw new Error('代码标注失败');
+        throw new Error('代码标注失败，请稍后重试！或刷新后重试！');
     }
 
     // 可能所有的前端都不选
@@ -282,6 +282,8 @@ function getAuthApiPathList(app: App, frontends: Array<Frontend>) {
             logicItems = state.arguments?.map((item) => item.expression);
         } else if (state instanceof CallInterface) {
             logicItems = state.arguments?.map((item) => item.expression);
+        } else if (state instanceof ExternalDestination) {
+            logicItems = [state.anchor, state.link];
         } else if (state instanceof MemberExpression) {
             logicItems = [state.object, state.property];
         } else if (state instanceof StringInterpolation) {

package/src/server/entity2LogicNamespace.ts

@@ -212,7 +212,7 @@ export function entity2LogicNamespace(entity: Entity) {
                 returns: [
                     new Return({
                         name: 'result',
-                        typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                        typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                     }),
                 ],
                 body: [],

package/src/server/extendBaseNode.ts

@@ -70,6 +70,18 @@ BaseNode.prototype.findUsage = function findUsage() {
         console.log(err);
     }
 };
+
+// 通过当前节点，查找被引用的节点
+BaseNode.prototype.nodeFindRefNodes = function nodeFindRefNodes() {
+    try {
+        const app = this.getAncestor('App');
+        const naslServer = (app as any).naslServer as NaslServer;
+        return naslServer.nodeFindRefNodes(this);
+    } catch (err) {
+        console.log(err);
+    }
+};
+
 BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = false) {
     try {
         /**

package/src/server/formatTsUtils.ts

@@ -122,7 +122,7 @@ export function displayString2TypeAnnotation(typeStr: string, parentPrefix?: str
     if (type === 'Promise<void>')
         return null;
     // 把后面结尾里带()的比如
-    // 'function nasl.core.add(left: nasl.core.Integer, right: nasl.core.Integer): nasl.core.Integer (+12 overloads)'
+    // 'function nasl.core.add(left: nasl.core.Long, right: nasl.core.Long): nasl.core.Long (+12 overloads)'
     if (type.includes('(') && type.includes(')')) {
         type = type.replace(/\([^\)]*\)/g, '');
     }
@@ -389,7 +389,7 @@ function getAStructureScopeType(type: string, parent: any, node: BaseNode) {
         entity1: app.dataSources.defaultDS.entities.Entity1;
         lCAPRolePerMapping: app.dataSources.defaultDS.entities.LCAPRolePerMapping;
     }>;
-    total: nasl.core.Integer;
+    total: nasl.core.Long;
 }`
  */
 function getAStructureObjectStringType(type: string, parent: any, node: BaseNode) {
@@ -547,6 +547,7 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
             // 如果是从实体或者数据结构取的属性，就需要重置一下类型
             item.concept = 'CompletionProperty';
             const completionProperty = new CompletionProperty(item);
+            completionProperty.jsonName = item.jsonName;
             // 标记实体属性是否是符合类型
             if (typeof item.isComplexType === 'boolean') {
                 Object.assign(completionProperty, { isComplexType: item.isComplexType });

package/src/server/getMemberIdentifier.ts

@@ -150,8 +150,11 @@ function getCurrentLogic(node: BaseNode,
         expanded: boolean;
         icon: string;
     }[]) {
-    // 只有data-source可以
-    if (node instanceof Identifier && node.parentNode instanceof BindAttribute && (node.parentNode.name === 'data-source' || node.parentNode.name === 'check-file')) {
+    // 只有data-source check-file可以
+    if (
+        (node instanceof BindAttribute && (node.name === 'data-source' || node.name === 'check-file'))
+        || (node instanceof Identifier && node.parentNode instanceof BindAttribute && (node.parentNode.name === 'data-source' || node.parentNode.name === 'check-file'))
+    ) {
         const view = node.view;
         const viewLogics = view.logics;
         const logicVariable = viewLogics.map((item) => {