@lcap/nasl 2.18.0 → 2.19.0-beta.2

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,18 +28,35 @@ 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 }>,
     };
 
-    const NaslAnnotatedJSON = await (app as any).naslServer.getNaslAnnotatedJSON(app, true);
+    if (logicPageResourceDtoList)
+        Object.assign(body, { logicPageResourceDtoList });
+
+    let NaslAnnotatedJSON;
+    try {
+        NaslAnnotatedJSON = await (app as any).naslServer.getNaslAnnotatedJSON(app, true);
+    } catch (err) {
+        console.error(err);
+        throw new Error('代码标注失败');
+    }
 
     let files = genBundleFiles(app, Object.assign({}, appInfo, {
         env,
@@ -59,7 +77,9 @@ export async function genReleaseBody(app: App, {
     const jsonString = JSON.stringify(NaslAnnotatedJSON);
 
     // 打印传给服务端的nasl,为了服务端排查问题方便
-    // console.warn(NaslAnnotatedJSON, '标注后的nasl');
+    if (globalThis.window) {
+        console.log(NaslAnnotatedJSON, '标注后的nasl');
+    }
     files.push({ name: 'nasl-annotated.json', content: jsonString });
 
     body.files = files;
@@ -73,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 }>,
     };
 
@@ -100,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) => ({
@@ -240,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';

package/src/generator/permission.ts

@@ -0,0 +1,271 @@
+import { Logic, View, BaseNode, CallLogic, ViewElement, BindEvent, BindAttribute, App, Entity, Module } from "../concepts";
+import { processToTreeFragment } from '../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 View) 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 View) 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, uploaders: Map<string, ViewElement[]>) {
+    const logics = await findViewLogicReferences(logic);
+    logics.push(logic);
+    
+    let UIs: Array<View | ViewElement> = [];
+    for(const logic of logics) {
+        UIs = UIs.concat(await findUIReferences(logic));
+    }
+
+    const service = logic.toService() as { url: { method: string, path: string } };
+    if(uploaders.has(service.url.path)) {
+        UIs = UIs.concat(uploaders.get(service.url.path));
+    }
+
+    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: processLogics,
+    };
+}
+
+function findUploaders(app: App) {
+    const map = new Map<string, ViewElement[]>();
+    app.traverseChildren((node) => {
+        if(node instanceof ViewElement && node.tag?.includes('uploader')) {
+            const urlAttr = node.bindAttrs.find((item) => item.name === 'url');
+            const url = urlAttr?.value;
+            if(url) {
+                if(!map.has(url))
+                    map.set(url, [node]);
+                else
+                    map.get(url).push(node);
+            }
+        }
+    });
+    return map;
+}
+
+export async function genPermissionData(app: App) {
+    // console.time('xxx');
+    openCache();
+    const logicPageResourceDtoList: { [key: string]: ResourceNode[][] } = {};
+    const { logics, processLogics } = getAllLogics(app);
+    const uploaders = findUploaders(app);
+    for(const logic of [...logics, ...processLogics]) {
+        let resources = await findResourcesOfLogic(logic, uploaders);
+        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;
+    }
+    closeCache();
+    // console.timeEnd('xxx');
+    return logicPageResourceDtoList;
+}

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, 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({
@@ -135,15 +155,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 +178,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 +297,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

@@ -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();
@@ -235,6 +222,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 +230,12 @@ 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 || (node.parentNode instanceof View && minRange.node instanceof Destination)) {
+                                minRange.node.deleteCalleeArg(Index);
                             }
                         }
                     });
@@ -354,14 +343,14 @@ BaseNode.prototype.addParamsPrepare = async function addParamsPrepare(needAdd =
 /**
  * 在原型上增加方法来调用
  */
-BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnotation() {
+BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnotation(outTime? :number) {
     try {
         /**
          * 查找这个节点是不是有依赖
          */
         const app = this.getAncestor('App');
         const naslServer = (app as any).naslServer as NaslServer;
-        return naslServer.getCurrentTypeAnnotation(this);
+        return naslServer.getCurrentTypeAnnotation(this, outTime || 2000);
     } catch (err) {
         console.log(err);
     }