@lcap/nasl 2.18.0 → 2.20.0-beta.1

package/src/generator/permission.ts

@@ -0,0 +1,261 @@
+import { Logic, View, BaseNode, CallLogic, ViewElement, BindEvent, BindAttribute, App, Entity, Module, Frontend } from '../concepts';
+import { processToTreeFragment } from '@nasl/server/process2LogicNamespace';
+
+type Usage = {
+    node: BaseNode,
+    children?: Usage[],
+}
+type ResourceNode = {
+    path: string,
+    type: 'component' | 'page',
+};
+
+function isReadOnly(logic: Logic) {
+    return !!logic.module
+        || logic.parentNode?.concept === 'Namespace'
+        || logic.parentKey === 'readonly'; // process logic
+}
+
+const cache = new Map();
+let useCache = false;
+async function findUsage(logic: Logic) {
+    if (useCache && cache.has(logic))
+        return cache.get(logic);
+
+    const res = isReadOnly(logic) ? await logic.findReadOnlyLogicUsage() : await logic.findUsage();
+    if (useCache)
+        cache.set(logic, res);
+    return res;
+}
+
+function openCache() {
+    useCache = true;
+    cache.clear();
+}
+function closeCache() {
+    useCache = false;
+    cache.clear();
+}
+
+async function findViewLogicReferences(logic: Logic, vis: Set<Logic> = new Set()) {
+    const usageMap: Map<BaseNode, Usage> = await findUsage(logic);
+    const usages: Usage[] = [];
+    usageMap.forEach((usage: Usage, node: BaseNode) => {
+        if (node instanceof Frontend)
+            usages.push(usage);
+    });
+
+    async function dfs(usage: Usage) {
+        if (usage.node instanceof CallLogic) {
+            const logic = usage.node.logic;
+            if (!vis.has(logic)) {
+                vis.add(logic);
+                await findViewLogicReferences(logic, vis);
+            }
+        }
+
+        if (usage.children) {
+            for (const child of usage.children) {
+                await dfs(child);
+            }
+        }
+    }
+
+    for (const usage of usages) {
+        await dfs(usage);
+    }
+
+    return Array.from(vis);
+}
+
+async function findUIReferences(logic: Logic) {
+    const usageMap: Map<BaseNode, Usage> = await findUsage(logic);
+    const usages: Usage[] = [];
+    usageMap.forEach((usage: Usage, node: BaseNode) => {
+        if (node instanceof Frontend)
+            usages.push(usage);
+    });
+
+    const res: Array<View | ViewElement> = [];
+    function dfs(usage: Usage, parent: Usage = null) {
+        if ((usage.node instanceof BindEvent || usage.node instanceof BindAttribute)
+            && (parent.node instanceof View || parent.node instanceof ViewElement))
+            res.push(parent.node);
+
+        usage.children?.forEach((child) => {
+            dfs(child, usage);
+        });
+    }
+
+    usages.forEach((usage) => {
+        dfs(usage);
+    });
+    return res;
+}
+
+function findResourcesOfUI(view: View | ViewElement) {
+    const res: ResourceNode[] = [];
+    let node: BaseNode = view;
+    while (node) {
+        if (node instanceof View && node.auth)
+            res.push({
+                path: node.authPath,
+                type: 'page',
+            });
+        else if (node instanceof ViewElement) {
+            const hasAuth = node.bindDirectives.find((directive) => directive.name === 'auth');
+            if (hasAuth)
+                res.push({
+                    path: node.authPath,
+                    type: 'component',
+                });
+        }
+        node = node.parentNode;
+    }
+    return res;
+}
+
+function optimizeResourceData(resources: ResourceNode[][]) {
+    let res = removeRedundantResourceData(resources);
+    res = removeRedundantResourceData2(res);
+    return res;
+}
+
+// [['b'], ['a' ,'b']] 只需要保留 [['b']]
+function removeRedundantResourceData(resources: ResourceNode[][]) {
+    const wm: WeakMap<ResourceNode[], string> = new WeakMap();
+    for (const resource of resources) {
+        const hash = resource.map(({ path, type }) => `${path}_${type}`)
+            .join();
+        wm.set(resource, hash);
+    }
+
+    resources.sort((a, b) => wm.get(a).length - wm.get(b).length);
+
+    const res: ResourceNode[][] = [];
+    const hashs: string[] = [];
+
+    for (const resource of resources) {
+        const hash = wm.get(resource);
+        if (hashs.some((h) => hash.endsWith(h)))
+            continue;
+
+        res.push(resource);
+        hashs.push(hash);
+    }
+    return res;
+}
+
+// 子页面有权限，父页面默认也有权限，所以不需要记录父页面权限；
+// 组件有权限，组件所在的页面默认也有权限，所以不需要记录页面权限
+function removeRedundantResourceData2(resources: ResourceNode[][]) {
+    return resources.map((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((item) => item.type === 'component');
+    });
+}
+
+async function findResourcesOfLogic(logic: Logic) {
+    const logics = await findViewLogicReferences(logic);
+    logics.push(logic);
+
+    let UIs: Array<View | ViewElement> = [];
+    for (const logic of logics) {
+        UIs = UIs.concat(await findUIReferences(logic));
+    }
+    UIs = Array.from(new Set(UIs));
+
+    const res = UIs.map((ui) => findResourcesOfUI(ui));
+
+    return optimizeResourceData(res);
+}
+
+function getAllLogics(app: App) {
+    const modules: Module[] = [];
+    const entities: Entity[] = [];
+    const logics: Logic[] = [];
+
+    if (Array.isArray(app.dataSources)) {
+        app.dataSources.forEach((dataSource) => {
+            if (Array.isArray(dataSource.entities)) {
+                entities.push(...dataSource.entities);
+            }
+        });
+    }
+    app.logics && logics.push(...app.logics);
+
+    app.dependencies && modules.push(...app.dependencies);
+    app.interfaceDependencies && modules.push(...app.interfaceDependencies);
+
+    modules.forEach((module: Module) => {
+        module.logics && logics.push(...module.logics);
+        if (Array.isArray(module.dataSources)) {
+            module.dataSources.forEach((dataSource) => {
+                if (Array.isArray(dataSource.entities)) {
+                    entities.push(...dataSource.entities);
+                }
+            });
+        }
+    });
+
+    const allLogics: Logic[] = [];
+
+    if (Array.isArray(entities)) {
+        entities.forEach((entity) => {
+            const ns = entity.ns;
+            if (Array.isArray(ns?.logics)) {
+                allLogics.push(...ns.logics);
+            }
+        });
+    }
+    if (Array.isArray(logics)) {
+        allLogics.push(...logics);
+    }
+
+    const processLogics: Logic[] = [];
+    const processTreeFragments = (app.processes || [])
+        .map(processToTreeFragment);
+    processTreeFragments.forEach((tree) => {
+        processLogics.push(...tree.logics);
+        tree.elements.forEach((element) => {
+            processLogics.push(...element.logics);
+        });
+    });
+
+    return {
+        logics: allLogics,
+        processLogics,
+    };
+}
+
+export async function genPermissionData(app: App) {
+    // console.time('xxx');
+    openCache();
+    const logicPageResourceDtoList: { [key: string]: ResourceNode[][] } = {};
+    const resourceList: string[] = [];
+    const resourceDataList: { value: string, type: 'logic', description: string }[] = [];
+    const { logics, processLogics } = getAllLogics(app);
+    for (const logic of [...logics, ...processLogics]) {
+        const resources = await findResourcesOfLogic(logic);
+        if (resources.length === 0)
+            continue;
+
+        const service = logics.includes(logic) ? logic.toService() : logic.toProcessService() as { url: { method: string, path: string } };
+        const key = `${service.url.path}:${service.url.method}`;
+        logicPageResourceDtoList[key] = resources;
+        resourceList.push(key);
+        resourceDataList.push({
+            value: key,
+            type: 'logic',
+            description: logic.description,
+        });
+    }
+    closeCache();
+    // console.timeEnd('xxx');
+    return { logicPageResourceDtoList, resourceList, resourceDataList };
+}

package/src/index.ts

@@ -1,6 +1,6 @@
 export { EventEmitter, EventPayload, BaseNode } from './common';
 export * from './concepts';
-export { genBundleFiles, genMetaData, genReleaseBody } from './generator';
+export { genBundleFiles, genFrontendBundleFiles, genMetaData, genReleaseBody, genPermissionData } from './generator';
 export * from './translator';
 // export { default as diagnosticManager } from './manager/diagnostic';
 export { default as server, NaslServer } from './server';

package/src/server/entity2LogicNamespace.ts

@@ -1,4 +1,4 @@
-import { CallLogic, EntityProperty, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Function, Return } from '..';
+import { CallLogic, EntityProperty, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Function, Return, AnonymousFunction, NewList } from '..';
 
 export function entity2LogicNamespace(entity: Entity) {
     const properties = entity.properties;
@@ -86,6 +86,26 @@ export function entity2LogicNamespace(entity: Entity) {
                         }),
                         required: true,
                     }),
+                    new Param({
+                        name: 'properties',
+                        defaultExpression: new AnonymousFunction({
+                            description: '',
+                            params: [
+                                new Param({
+                                    name: 'item',
+                                    typeAnnotation: new TypeAnnotation({
+                                        typeKind: 'reference',
+                                        typeNamespace: entity.getNamespace(),
+                                        typeName: entity.name,
+                                    }),
+                                }),
+                            ],
+                            body: new NewList({
+                                concept: 'NewList',
+                            }),
+                        }),
+                        required: false,
+                    }),
                 ],
                 returns: [
                     new Return({
@@ -118,6 +138,26 @@ export function entity2LogicNamespace(entity: Entity) {
                         }),
                         required: true,
                     }),
+                    new Param({
+                        name: 'properties',
+                        defaultExpression: new AnonymousFunction({
+                            description: '',
+                            params: [
+                                new Param({
+                                    name: 'item',
+                                    typeAnnotation: new TypeAnnotation({
+                                        typeKind: 'reference',
+                                        typeNamespace: entity.getNamespace(),
+                                        typeName: entity.name,
+                                    }),
+                                }),
+                            ],
+                            body: new NewList({
+                                concept: 'NewList',
+                            }),
+                        }),
+                        required: false,
+                    }),
                 ],
                 body: [],
                 returns: [
@@ -135,15 +175,6 @@ export function entity2LogicNamespace(entity: Entity) {
                 name: 'updateBy',
                 description: '根据条件，将body除id外所有属性更新到数据记录',
                 params: [
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                        required: true,
-                    }),
                     new Param({
                         name: 'filter',
                         defaultExpression: new Function({
@@ -167,6 +198,35 @@ export function entity2LogicNamespace(entity: Entity) {
                         }),
                         required: true,
                     }),
+                    new Param({
+                        name: 'body',
+                        typeAnnotation: new TypeAnnotation({
+                            typeKind: 'reference',
+                            typeNamespace: entity.getNamespace(),
+                            typeName: entity.name,
+                        }),
+                        required: true,
+                    }),
+                    new Param({
+                        name: 'properties',
+                        defaultExpression: new AnonymousFunction({
+                            description: '',
+                            params: [
+                                new Param({
+                                    name: 'item',
+                                    typeAnnotation: new TypeAnnotation({
+                                        typeKind: 'reference',
+                                        typeNamespace: entity.getNamespace(),
+                                        typeName: entity.name,
+                                    }),
+                                }),
+                            ],
+                            body: new NewList({
+                                concept: 'NewList',
+                            }),
+                        }),
+                        required: false,
+                    }),
                 ],
                 returns: [
                     new Return({
@@ -257,6 +317,26 @@ export function entity2LogicNamespace(entity: Entity) {
                         }),
                         required: true,
                     }),
+                    new Param({
+                        name: 'properties',
+                        defaultExpression: new AnonymousFunction({
+                            description: '',
+                            params: [
+                                new Param({
+                                    name: 'item',
+                                    typeAnnotation: new TypeAnnotation({
+                                        typeKind: 'reference',
+                                        typeNamespace: entity.getNamespace(),
+                                        typeName: entity.name,
+                                    }),
+                                }),
+                            ],
+                            body: new NewList({
+                                concept: 'NewList',
+                            }),
+                        }),
+                        required: false,
+                    }),
                 ],
                 returns: [
                     new Return({

package/src/server/extendBaseNode.ts

@@ -1,7 +1,7 @@
 import { FileNode, NaslServer } from './naslServer';
 import * as tsProtocol from 'typescript/lib/protocol';
 import { MinRange } from './translator';
-import { BaseNode, CallLogic, Destination, EnumItem, Interface, Logic, Param, Process, Role, Structure, View, ViewElement } from '../concepts';
+import { BaseNode, CallLogic, Destination, EnumItem, Interface, Logic, Param, Process, Role, Structure, View, ViewElement, Frontend } from '../concepts';
 import { EventPayload, invokeCommand, registerCommand } from '../common';
 
 interface SetNameNode extends BaseNode {
@@ -161,19 +161,6 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
         refsList = refsList.filter((item) =>
             // 因为ui组件本身会多渲染一次,就先过滤一个
             !(item.lineText.includes(': nasl.ui.')));
-        // 删除参数单独处理
-        if (node instanceof Param) {
-            const methodRefs: tsProtocol.ReferencesResponseItem[] = [];
-            refsList.forEach((item) => {
-                // 入参查找引用,查到logic 和自己,内容完全一样,就保留一个
-                const find = methodRefs.find((findItem) => item.lineText === findItem.lineText);
-                if (!find) {
-                    methodRefs.push(item);
-                }
-            });
-            refsList = methodRefs;
-        }
-
         // delete的弹框展示
         const confirmParms = {
             actionType: 'delete',
@@ -182,7 +169,7 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
             icon: 'warning',
         };
         let callback = null;
-        if (refsList.length <= 1) {
+        if (refsList.length <= 1 || (node instanceof Param && node.parentNode instanceof Logic && refsList.length <= 2)) {
             // 页面组件直接删除然后return
             if (node instanceof ViewElement) {
                 this.delete();
@@ -202,7 +189,7 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
             const node = this;
 
             // 删除页面或者流程
-            if (node instanceof View || node instanceof Process) {
+            if (node instanceof View || node instanceof Process || node instanceof Frontend) {
                 /**
                  * 查找这个页面是不是有依赖
                  */
@@ -222,7 +209,33 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                     } else {
                         this.delete();
                     }
-                    return;
+                } else {
+                    if (node instanceof Frontend) {
+                        let viewPath = (this as FileNode).getEmbeddedFilePath();
+                        viewPath = viewPath.slice(0, viewPath.length - 3);
+                        const refsTempList = refsList.filter((record) => !record.file.includes(viewPath));
+                        // 删除流程节点绑定的该端的页面跳转
+                        const result = refsTempList
+                            .map((record) => {
+                                const fileNode = naslServer.file2NodeMap.get(record.file);
+                                if (fileNode) {
+                                    const minRange = naslServer._findMinRange(record, fileNode as FileNode);
+                                    if (minRange?.node?.parentNode?.parentNode?.concept === 'ProcessElement') {
+                                        return minRange.node.parentNode;
+                                    }
+                                }
+                                return null;
+                            }).filter((record) => !!record);
+                        console.log(result);
+                        const App = this.rootNode;
+                        App.emit('collect:start', {
+                            actionMsg: `删除端${node.name}`,
+                        });
+                        await Promise.all(result.map((ele) => ele.delete()));
+                        this.delete();
+                        App.emit('collect:end');
+                        return;
+                    }
                 }
             }
             callback = async () => {
@@ -235,6 +248,7 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                     App.emit('collect:start', {
                         actionMsg: '删除参数',
                     });
+                    const Index = node.getIndexOfParent();
                     this.delete();
                     refsList.forEach((record) => {
                         const fileNode = naslServer.file2NodeMap.get(record.file);
@@ -242,11 +256,8 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                             return null;
                         const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
                         if (minRange) {
-                            if (minRange.node instanceof CallLogic) {
-                                minRange.node.setCalleeArgName(parentNode as Logic);
-                            }
-                            if (minRange.node instanceof Destination) {
-                                minRange.node.setViewArgument(parentNode as View);
+                            if (minRange.node instanceof CallLogic || minRange.node instanceof Destination) {
+                                minRange.node.deleteCalleeArg(Index);
                             }
                         }
                     });

package/src/server/formatTsUtils.ts

@@ -247,13 +247,9 @@ function findNode(typeKey: string, node: BaseNode) {
  * 获取下一级的节点进行递归
  * @param typeKey 当前节点的类型，主要为了取出内部的 T中的实际类型
  * @param item 当前节点的内容
- * @param parent 父级节点的内容
  * @param node 获取变量框的位置
  */
-export function nextFindTypeChild(typeKey: string, item: any, parent: any, node: BaseNode) {
-    // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
-    const nodeMap = parent ? parent.nodeMap : new Map();
-    item.nodeMap = nodeMap;
+export function nextFindTypeChild(typeKey: string, item: any, node: BaseNode) {
     const newType = findNode(typeKey, node);
     if ((newType as Structure)?.properties && (newType as Structure).properties.length) {
         // 处理泛型的内容要取到值
@@ -274,16 +270,7 @@ export function nextFindTypeChild(typeKey: string, item: any, parent: any, node:
                 });
             }
         });
-        const index = nodeMap.get(newType) || 0;
-        if (index) {
-            nodeMap.set(newType, index + 1);
-        } else {
-            nodeMap.set(newType, 1);
-        }
-        // 最多保留3层
-        if (index < 3) {
-            item.children = formatVariableData(newStructure.properties, node, item);
-        }
+        item.children = formatVariableData(newStructure.properties, node, item);
     }
 }
 
@@ -359,7 +346,7 @@ function getAStructureScopeType(type: string, parent: any, node: BaseNode) {
                     newItem.concept = 'CompletionProperty';
                     // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
                     if (item.typeKey && !isNoChildType(item.typeKey)) {
-                        newItem.children = nextObjectTypeChild(item.typeKey, newItem, parentItem, node);
+                        newItem.children = nextObjectTypeChild(item.typeKey, newItem, node);
                     }
                     const completionProperty = new CompletionProperty(newItem);
                     completionProperty.icon = 'refProperty';
@@ -395,9 +382,6 @@ function getAStructureScopeType(type: string, parent: any, node: BaseNode) {
 function getAStructureObjectStringType(type: string, parent: any, node: BaseNode) {
     let newType = type.replaceAll(' ', '').replaceAll('\n', '').replace(/__name:"AStructure_\w{8}";/g, '');
     newType = newType.substring(1, newType.length - 1);
-    if (!parent.keyMap) {
-        parent.keyMap = new Map();
-    }
     if (/\{([^()]+)\}/.exec(newType)) {
         newType = newType.replace(/\{([^()]+)\}/, '');
     }
@@ -437,7 +421,7 @@ function getAStructureObjectStringType(type: string, parent: any, node: BaseNode
         newItem.concept = 'CompletionProperty';
         // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
         if (item.typeKey && !isNoChildType(item.typeKey)) {
-            newItem.children = nextObjectTypeChild(getPlatformType(item.typeKey), newItem, parentItem, node);
+            newItem.children = nextObjectTypeChild(getPlatformType(item.typeKey), newItem, node);
         }
         const completionProperty = new CompletionProperty(newItem);
 
@@ -451,13 +435,7 @@ function getAStructureObjectStringType(type: string, parent: any, node: BaseNode
     completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
     return completionProperty;
 }
-function nextObjectTypeChild(typeKey: string, item: any, parent: any, node: BaseNode) {
-    // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
-    const nodeMap = parent.nodeMap || new Map();
-    item.nodeMap = nodeMap; // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
-
-    const keyMap = parent.keyMap;
-    item.keyMap = keyMap;
+function nextObjectTypeChild(typeKey: string, item: any, node: BaseNode) {
     const newType = findNode(typeKey, node);
     if ((newType as Structure)?.properties && (newType as Structure).properties.length) {
         // 处理泛型的内容要取到值
@@ -478,16 +456,7 @@ function nextObjectTypeChild(typeKey: string, item: any, parent: any, node: Base
                 });
             }
         });
-        const index = nodeMap.get(newType) || 0;
-        if (index) {
-            nodeMap.set(newType, index + 1);
-        } else {
-            nodeMap.set(newType, 1);
-        }
-        // 最多保留3层
-        if (index < 3) {
-            return formatVariableData(newStructure.properties, node, item);
-        }
+        return formatVariableData(newStructure.properties, node, item);
     }
 }
 
@@ -533,21 +502,42 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
                 item.name = item.text;
                 const identifier = new Identifier({ name: item.name });
                 item.expression = identifier;
+                item.typeKey = typeKey;
             } else {
                 item.value = `${parent.value}.${item.name}`;
+                const object: any = BaseNode.from(parent.expression.toJSON());
                 const memberExpression = new MemberExpression({
-                    object: parent.expression,
+                    object,
                     property: new Identifier({ name: item.name }),
                 });
                 item.expression = memberExpression;
+                item.variableParent = parent;
+                item.typeKey = typeKey;
+                // 标记实体属性是否是符合类型
+                item.isComplexType = item.typeAnnotation?.isComplexType();
             }
             // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
             if (typeKey && !isNoChildType(typeKey)) {
-                nextFindTypeChild(typeKey, item, parent, node);
+                let currentParent = item;
+                let typeKeyIndex = 0;
+                while (currentParent.variableParent) {
+                    currentParent = currentParent.variableParent;
+                    if (currentParent.typeKey === typeKey) {
+                        typeKeyIndex++;
+                    }
+                }
+                // 向上找到3次一样的就结束
+                if (typeKeyIndex < 3) {
+                    nextFindTypeChild(typeKey, item, node);
+                }
             }
             // 如果是从实体或者数据结构取的属性，就需要重置一下类型
             item.concept = 'CompletionProperty';
             const completionProperty = new CompletionProperty(item);
+            // 标记实体属性是否是符合类型
+            if (typeof item.isComplexType === 'boolean') {
+                Object.assign(completionProperty, { isComplexType: item.isComplexType });
+            }
             if (!parent) {
                 // 变量 param return 在这里添加图标
                 completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
@@ -633,20 +623,20 @@ function sortFirstVariableData(result: CompletionProperty[], node: BaseNode) {
 }
 
 export function formatFrontEndVariables(frontEndVariables: Array<Variable>) {
-    const result = frontEndVariables.map((item) => {
-        const namespace = item.getNamespace();
+    const result = frontEndVariables.map((itemNode) => {
+        const namespace = itemNode.getNamespace();
         const newItem: any = {
-            name: item.name,
-            value: item.name,
+            name: itemNode.name,
+            value: itemNode.name,
             expression: new Identifier({
-                name: item.name,
+                name: itemNode.name,
                 namespace,
             }),
         };
-        const noChildType = isNoChildType(item.typeAnnotation.typeKey);
+        const noChildType = isNoChildType(itemNode.typeAnnotation.typeKey);
 
         if (!noChildType) {
-            nextFindTypeChild(item.typeAnnotation.typeKey, newItem, null, item);
+            nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);
         }
         const completionProperty = new CompletionProperty(newItem);
         completionProperty.icon = 'frontendVariable';