@lcap/nasl 2.18.0-beta.7 → 2.19.0-beta.1

package/src/concepts/index__.ts

@@ -65,6 +65,10 @@ export * from './Match__';
 export * from './UnaryExpression__';
 export * from './MemberExpression__';
 export * from './Unparsed__';
+export * from './New__';
+export * from './NewComposite__';
+export * from './NewList__';
+export * from './NewMap__';
 export * from './CallQueryComponent__';
 export * from './QueryFromExpression__';
 export * from './QueryJoinExpression__';
@@ -81,6 +85,7 @@ export * from './ProcessElement__';
 export * from './ProcessComponent__';
 export * from './ProcessOutcome__';
 export * from './Assignee__';
+export * from './ProcessOutcomes__';
 export * from './Role__';
 export * from './Configuration__';
 export * from './ConfigGroup__';

package/src/enums/KEYWORDS.ts

@@ -1225,4 +1225,5 @@ export const USER_CUSTOM_KEYWORDS_PAGENAME = [
     'getCustomConfig',
     'getCurrentIp',
     'config',
+    'tenantExpiration',
 ];

package/src/generator/dist/genMetaData.js

@@ -186,11 +186,7 @@ function genMetaData(app) {
     });
     utils.traverse(function (current) {
         var node = (current || {}).node;
-        var concept = (node || {}).concept;
-        var typeAnnotation;
-        if (['Param', 'Variable', 'Return', 'CallFunction', 'CallInterface', 'CallLogic'].includes(concept)) {
-            typeAnnotation = node.typeAnnotation || node.__TypeAnnotation;
-        }
+        var typeAnnotation = (node === null || node === void 0 ? void 0 : node.typeAnnotation) || (node === null || node === void 0 ? void 0 : node.__TypeAnnotation);
         collectTypeAnnotation(typeAnnotation);
     }, {
         node: {

package/src/generator/dist/permission.js

@@ -0,0 +1,392 @@
+"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 ((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: 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()]);
+                    _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); });
+                    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/genMetaData.ts

@@ -217,12 +217,7 @@ export function genMetaData(app: App) {
 
     utils.traverse((current) => {
         const { node } = current || {};
-        const { concept } = node || {};
-        let typeAnnotation;
-        if (['Param', 'Variable', 'Return', 'CallFunction', 'CallInterface', 'CallLogic'].includes(concept)) {
-            typeAnnotation = node.typeAnnotation || node.__TypeAnnotation;
-        }
-        collectTypeAnnotation(typeAnnotation);
+        collectTypeAnnotation(node?.typeAnnotation || node?.__TypeAnnotation);
     }, {
         node: {
             children: views,

package/src/generator/genReleaseBody.ts

@@ -1,5 +1,6 @@
-import { App, Assignment, BatchAssignment, CallFunction, CallInterface, CallLogic, ForEachStatement, IfStatement, Logic, LogicItem, Match, MatchCase, Role, SwitchCase, SwitchStatement, View, ViewElement, WhileStatement } from '../concepts';
+import { App, Assignment, BatchAssignment, CallFunction, CallInterface, CallLogic, ForEachStatement, IfStatement, Logic, LogicItem, Match, MatchCase, MemberExpression, Role, SwitchCase, SwitchStatement, View, ViewElement, WhileStatement, StringInterpolation } from '../concepts';
 import { genBundleFiles } from './genBundleFiles';
+import { genPermissionData } from './permission';
 
 export async function genReleaseBody(app: App, {
     env,
@@ -27,16 +28,28 @@ export async function genReleaseBody(app: App, {
     },
     staticUrl?: string,
 }) {
+    let authReport: ReturnType<typeof getAuthReport>;
+    let logicPageResourceDtoList;
+    if (realRelease) {
+        authReport = getAuthReport(app);
+        logicPageResourceDtoList = await genPermissionData(app);
+    }
+
     const body = {
-        ...(realRelease ? getAuthReport(app) : undefined), // 如果发布需要上报权限，导出源码不需要
+        ...authReport, // 如果发布需要上报权限，导出源码不需要
         noAuthApiPathList: getAuthApiPathList(app),
         reportIdList: findAllReportIdList(app),
         appId: app.id,
         env,
         replicas,
+        callbackLogicsName: app.getExtensionsCallbackLogics(),
         generateMini,
         files: [] as Array<{ name: string, content: string }>,
     };
+
+    if (logicPageResourceDtoList)
+        Object.assign(body, { logicPageResourceDtoList });
+
     let NaslAnnotatedJSON;
     try {
         NaslAnnotatedJSON = await (app as any).naslServer.getNaslAnnotatedJSON(app, true);
@@ -80,7 +93,7 @@ function getAuthReport(app: App) {
     const result = {
         roleList: [] as Array<Role>,
         resourceList: [] as Array<string>,
-        resourceDataList: [] as Array<{ value: string, description: string }>,
+        resourceDataList: [] as Array<{ value: string, description: string, type: 'page' | 'component' | 'logic' }>,
         roleResourceMappingList: [] as Array<{ roleName: string, resourcePath: string }>,
     };
 
@@ -107,6 +120,7 @@ function getAuthReport(app: App) {
             result.resourceDataList.push({
                 value: view.authPath,
                 description: view.authDescription,
+                type: view.concept === 'View' ? 'page' : 'component',
             });
             if (view.bindRoles) {
                 const _arr = view.bindRoles.map((it) => ({
@@ -247,6 +261,10 @@ function getAuthApiPathList(app: App) {
             logicItems = state.arguments?.map((item) => item.expression);
         } else if (state instanceof CallInterface) {
             logicItems = state.arguments?.map((item) => item.expression);
+        } else if (state instanceof MemberExpression) {
+            logicItems = [state.object, state.property];
+        } else if (state instanceof StringInterpolation) {
+            logicItems = [...state.expressions];
         }
 
         return logicItems.filter((item) => !!item);

package/src/generator/index.ts

@@ -4,3 +4,4 @@ export * from './styleReplacer';
 export * from './genBundleFiles';
 export * from './genMetaData';
 export * from './genReleaseBody';
+export * from './permission';