@lcap/nasl 2.18.0-beta.7 → 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 {
@@ -189,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) {
                 /**
                  * 查找这个页面是不是有依赖
                  */
@@ -209,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 () => {

package/src/server/formatTsUtils.ts

@@ -513,6 +513,8 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
                 item.expression = memberExpression;
                 item.variableParent = parent;
                 item.typeKey = typeKey;
+                // 标记实体属性是否是符合类型
+                item.isComplexType = item.typeAnnotation?.isComplexType();
             }
             // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
             if (typeKey && !isNoChildType(typeKey)) {
@@ -532,6 +534,10 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
             // 如果是从实体或者数据结构取的属性，就需要重置一下类型
             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);

package/src/server/getLogics.ts

@@ -1,3 +1,4 @@
+import { Identifier } from './../concepts/Identifier__';
 import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process, ViewElement, stdlibNamespace, EnumItem } from '..';
 import { process2LogicNamespace } from './process2LogicNamespace';
 import { moduleToLogicNamesapce } from './getExtensionModules';
@@ -56,7 +57,7 @@ function iterator(tree: FakeNode | FakeProcessNode, searchContent: string, fakeN
 function toHump(name: string): string {
     return name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase());
 }
-export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boolean = true) {
+export async function getLogics(node: CallLogic | BindEvent| Identifier, needAllLogic: boolean = true) {
     const app = node.rootNode as App;
     if (node.concept === 'CallLogic' || node.concept === 'BindEvent') {
         const result = [];
@@ -264,6 +265,17 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             result.push(systemTree);
         }
         return result;
+    } else if (node.concept === 'Identifier') {
+        const extensions = app.dependencies.map(moduleToLogicNamesapce).filter((item) => item.logics && item.logics.length);
+        const tree = new Namespace({
+            name: 'category`',
+            path: `${app.getNamespace()}.logics`,
+            title: '全局逻辑',
+            logics: app.logics,
+            children: [...extensions],
+        });
+
+        return [tree];
     }
 }
 

package/src/server/getMemberIdentifier.ts

@@ -1,4 +1,4 @@
-import { BaseNode, CompletionProperty, App, Variable, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param, BindAttribute, LogicItem, TypeAnnotation, StructureProperty, Entity, Structure, EntityProperty } from '..';
+import { BaseNode, CompletionProperty, App, Variable, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param, BindAttribute, LogicItem, TypeAnnotation, StructureProperty, Entity, Structure, EntityProperty, Frontend, View } from '..';
 import { formatVariableData, formatFrontEndVariables } from './formatTsUtils';
 
 // 简单实现一版本的格式化nums
@@ -191,7 +191,7 @@ export async function getMemberIdentifier(node: BaseNode) {
 
         // 这个可能需要自己算一下
         const result = [
-            { name: '字面量', children: literals, expanded: true, icon: 'category' },
+            { name: '常量', children: literals, expanded: true, icon: 'category' },
             { name: '枚举', children: newEnums, expanded: false, icon: 'category' },
             { name: '变量', children: completionData, expanded: true, icon: 'category' },
             { name: '公共变量', children: globalVariable, expanded: false, icon: 'category' },
@@ -199,7 +199,7 @@ export async function getMemberIdentifier(node: BaseNode) {
         ];
         if ((node as Identifier).view) {
             // 获取前端全局变量
-            const frontEndVariable = getFrontEndVariablesIdentifier(node);
+            const frontEndVariable = getFrontEndVariablesIdentifier((node as Identifier).view);
             result.push({ name: '前端全局变量', children: frontEndVariable, expanded: true, icon: 'category' });
         }
         getCurrentLogic(node, result);
@@ -208,8 +208,8 @@ export async function getMemberIdentifier(node: BaseNode) {
 }
 
 export function getFrontEndVariablesIdentifier(node: BaseNode) {
-    const app = node.rootNode as App;
-    const frontEndVariables = app?.frontendVariables;
+    const frontend = (node as View).frontend as Frontend;
+    const frontEndVariables = frontend?.variables;
     const newFrontEndVariables = frontEndVariables ? formatFrontEndVariables(frontEndVariables) : [];
     return newFrontEndVariables;
 }