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

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';