@lcap/nasl 2.13.0 → 2.13.1

package/src/server/getMemberIdentifier.ts

@@ -1,5 +1,6 @@
-import { BaseNode, CompletionProperty, App, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param, BindAttribute, LogicItem, TypeAnnotation } from '..';
+import { BaseNode, CompletionProperty, App, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param, BindAttribute, LogicItem, TypeAnnotation, StructureProperty, Entity, Structure, EntityProperty } from '..';
 import naslServer from './naslServer';
+import { getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 interface variableItem {
     text: string;
@@ -115,6 +116,8 @@ export function getPlatformType(tsType: string): string {
     const namespacePrefix = ['app', 'extensions', 'apis', 'components', 'nasl'];
     if (tsType === 'String') {
         return 'nasl.core.String';
+    } else if (tsType === 'Boolean') {
+        return 'nasl.core.Boolean';
     }
 
     const strTypes = tsType.split('.');
@@ -165,29 +168,97 @@ function sortFirstVariableData(result: CompletionProperty[], node: BaseNode) {
     newResult.push(...result);
     return newResult;
 }
+export function isNoChildType(type: String) {
+    return type?.startsWith('nasl.core') || type?.startsWith('app.enums');
+}
+function findNode(typeKey: string, node: BaseNode) {
+    let newType: Structure | Entity;
+    if (typeKey.startsWith('nasl.') && typeKey.includes('<')) {
+        const findGenericsIndex = typeKey.indexOf('<');
+        typeKey = typeKey.substring(0, findGenericsIndex);
+        const typeIndex = typeKey.lastIndexOf('.');
+        newType = getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
+    } else if (typeKey.startsWith('nasl.')) {
+        const typeIndex = typeKey.lastIndexOf('.');
+        newType = getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
+    } else {
+        newType = (node as Identifier)?.app?.findNodeByCompleteName(typeKey);
+    }
+    return newType;
+}
+
+/**
+ * 获取下一级的节点进行递归
+ * @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;
+    const newType = findNode(typeKey, node);
+    if (newType?.properties && newType.properties.length) {
+        // 处理泛型的内容要取到值
+        const StructureJson = newType.toJSON();
+        const newStructure = new Structure(StructureJson);
+        newStructure.properties.forEach((item: StructureProperty | EntityProperty) => {
+            const itemType = item?.typeAnnotation?.typeKey;
+            if (itemType === 'T' && /\<([^()]+)\>/g.exec(typeKey)) {
+                const newTypes = /\<([^()]+)\>/g.exec(typeKey);
+                // 找到当前原来的类型
+                const contentType = getPlatformType(newTypes[1]);
+                const typeNamespace = contentType.substring(0, contentType.lastIndexOf('.'));
+                const typeName = contentType.substring(contentType.lastIndexOf('.') + 1, contentType.length);
+                item.typeAnnotation = new TypeAnnotation({
+                    typeKind: 'reference',
+                    typeNamespace,
+                    typeName,
+                });
+            }
+        });
+        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);
+        }
+    }
+}
 // 格式化变量数据
 export function formatVariableData(data: unknown | variableItem[], node: BaseNode, parent?: any) {
     if (Array.isArray(data)) {
         let result = data.map((item) => {
-            // value需要拼接生成
-            item.value = parent ? `${parent.value}.${item.text}` : item.text;
-            item.name = item.text;
+            item.children = [];
             // 当前结构的typeAnnotation
             let typeAnnotation;
-            let type;
+            // 当前的类型如 app.entitys.entity1 nasl.core.String
+            let typeKey: string;
 
             if (item.completionDetail) {
-                let type = formatTs2TypeString(item.completionDetail.displayParts as Array<{ text: string; kind: string }>);
-                typeAnnotation = getCompletionDetailType(type);
-                type = getPlatformType(type);
+                // 当前节点的完整类型，主要是在有T的内容使用 nasl.list<Enum1> 内部匹配内容给里面子集的T赋值类型
+                const currentType: string = formatTs2TypeString(item.completionDetail.displayParts as Array<{ text: string; kind: string }>);
+                typeAnnotation = getCompletionDetailType(currentType);
+                typeKey = getPlatformType(currentType);
+            } else if (item instanceof StructureProperty) {
+                typeKey = item?.typeAnnotation?.typeKey;
             }
             // 如果没有父节点就是Identifier
             if (!parent) {
+                // value需要拼接生成
+                item.value = parent ? `${parent.value}.${item.text}` : item.text;
+                item.name = item.text;
                 const identifier = new Identifier({ name: item.name });
                 // 携带上当前的类型
                 identifier.typeAnnotation = typeAnnotation;
                 item.expression = identifier;
             } else {
+                item.value = `${parent.value}.${item.name}`;
                 const memberExpression = new MemberExpression({
                     object: parent.expression,
                     property: new Identifier({ name: item.name }),
@@ -196,19 +267,18 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
                 memberExpression.typeAnnotation = typeAnnotation;
                 item.expression = memberExpression;
             }
-            if (item.children) {
-                item.children = formatVariableData(item.children, node, item);
+            // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+            if (typeKey && !isNoChildType(typeKey)) {
+                nextFindTypeChild(typeKey, item, parent, node);
             }
+            const completionProperty = new CompletionProperty(item);
             if (!parent) {
-                const completionProperty = new CompletionProperty(item);
                 // 变量 param return 在这里添加图标
                 completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
-                return completionProperty;
             } else {
-                const completionProperty = new CompletionProperty(item);
                 completionProperty.icon = 'refProperty';
-                return completionProperty;
             }
+            return completionProperty;
         });
 
         /**
@@ -409,7 +479,7 @@ function getCurrentLogic(node: BaseNode,
             completionProperty.icon = 'logic';
             return completionProperty;
         });
-        result.push({ name: '逻辑', children: logicVariable, expanded: true, icon: 'category' });
+        result.push({ name: '逻辑', children: logicVariable, expanded: false, icon: 'category' });
     }
 }
 
@@ -436,10 +506,10 @@ export async function getMemberIdentifier(node: BaseNode) {
 
         // 这个可能需要自己算一下
         const result = [
-            { name: '字面量', children: literals, expanded: true, icon: 'category' },
-            { name: '枚举', children: newEnums, expanded: true, icon: 'category' },
-            { name: '变量', children: completionData, expanded: true, icon: 'category' },
-            { name: '公共变量', children: globalVariable, expanded: true, icon: 'category' },
+            { name: '字面量', children: literals, expanded: false, icon: 'category' },
+            { name: '枚举', children: newEnums, expanded: false, icon: 'category' },
+            { name: '变量', children: completionData, expanded: false, icon: 'category' },
+            { name: '公共变量', children: globalVariable, expanded: false, icon: 'category' },
             // { name: '流程变量', children: [] },
         ];
         getCurrentLogic(node, result);
@@ -463,19 +533,9 @@ export function getEnumsIdentifier(node: BaseNode): CompletionProperty[] {
 // 获取变量
 export async function getVariableIdentifier(node: BaseNode): Promise<CompletionProperty[]> {
     let completionData: CompletionProperty[] = [new CompletionProperty({})];
-    if (node instanceof Identifier || node instanceof MemberExpression) {
-        const value = (node as Identifier | MemberExpression).getValue();
-        if (value) {
-            const completion = (await naslServer.getValueSelectCompletion(node, value)) as variableItem[];
-            completionData = formatVariableData(completion, node);
-        } else {
-            const nextCompletion = await naslServer.getFieldKeySelectCompletion(node, '');
-            completionData = formatVariableData(nextCompletion, node);
-        }
-    } else {
-        const nextCompletion = await naslServer.getFieldKeySelectCompletion(node, '');
-        completionData = formatVariableData(nextCompletion, node);
-    }
+    // 只获取第一层内容
+    const nextCompletion = await naslServer.getFieldKeySelectCompletion(node, '');
+    completionData = formatVariableData(nextCompletion, node);
     return completionData;
 }
 

package/src/server/getProcesses.ts

@@ -1,6 +1,7 @@
 import Constant from '@nasl/concepts/Constant__';
 import { CompletionProperty, Process, ProcessElement, Namespace, Logic, TypeAnnotation, Return, Variable, StructureProperty, Param, Identifier, MemberExpression, LogicItem, App, BaseNode, Structure, Entity, EntityProperty } from '..';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
+import { isNoChildType, nextFindTypeChild } from './getMemberIdentifier';
 function alphaUpper(name: string) {
     if (!name) {
         return '';
@@ -250,20 +251,20 @@ export function genCompletionProperty(prefix: string[] = []):(v: Variable | Para
         if (t.length) {
             prevalue = `${t.join('.')}.`;
         }
-        const hasChild = ['reference', 'generic'].includes(v.typeAnnotation.typeKind);
-        const cp = new CompletionProperty({
+        const noChildType = isNoChildType(v.typeAnnotation.typeKey);
+        const item = {
             expression: m || p,
-            noFurther: !hasChild,
             name: v.name,
             value: prevalue + v.name,
+        };
 
-        });
-        console.log(cp.value);
-        cp.icon = v.concept;
-
-        if (hasChild) {
-            cp.children = [new CompletionProperty()];
+        if (!noChildType) {
+            nextFindTypeChild(v.typeAnnotation.typeKey, item, null, v);
         }
+
+        const cp = new CompletionProperty(item);
+        console.log(cp.value, v);
+        cp.icon = v.concept;
         return cp;
     };
 }
@@ -307,7 +308,6 @@ export function getProcessVariableSuggestions(node: Logic, abandonConstant: bool
         const cp = new CompletionProperty({
             name: us.name,
             value: us.name,
-            noFurther: true,
             children: [
                 ...us.returns.map(genCompletionProperty([process.name, us.name])),
                 ...(abandonConstant ? [] : us.constants.map(genCompletionProperty([process.name, us.name]))),
@@ -321,7 +321,6 @@ export function getProcessVariableSuggestions(node: Logic, abandonConstant: bool
     const processVariables = new CompletionProperty({
         name: process.name,
         value: process.name,
-        noFurther: true,
         children: [
             ...process.params.map(genCompletionProperty([process.name])),
             ...process.returns.map(genCompletionProperty([process.name])),
@@ -335,7 +334,6 @@ export function getProcessVariableSuggestions(node: Logic, abandonConstant: bool
             name: processElem.name,
             value: processElem.name,
             icon: processElem.type,
-            noFurther: true,
             children: processElem.variables.map(genCompletionProperty([process.name, processElem.name])),
         });
         scopeVariable.isProcess = true;
@@ -348,7 +346,6 @@ export function getProcessVariableSuggestions(node: Logic, abandonConstant: bool
             name: processElem.name,
             value: processElem.name,
             icon: processElem.type,
-            noFurther: true,
             children: processElem.constants.map(genCompletionProperty([process.name, processElem.name])),
         });
         scopeVariable.isProcess = true;
@@ -360,7 +357,6 @@ export function getProcessVariableSuggestions(node: Logic, abandonConstant: bool
             name: processElem.name,
             value: processElem.name,
             icon: processElem.type,
-            noFurther: true,
             children: [
                 ...processElem.variables.map(genCompletionProperty([process.name, processElem.name])),
                 ...processElem.returns.map(genCompletionProperty([process.name, processElem.name])),
@@ -457,7 +453,6 @@ export function getProcessVariableSuggestionsAll(node: ProcessElement) {
         const cp = new CompletionProperty({
             name: us.name,
             value: us.name,
-            noFurther: true,
             children: [
                 ...us.returns.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], [])),
                ...us.constants.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], [])),
@@ -472,7 +467,6 @@ export function getProcessVariableSuggestionsAll(node: ProcessElement) {
     const processVariables = new CompletionProperty({
         name: process.name,
         value: process.name,
-        noFurther: true,
         children: [
             ...process.params.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
             ...process.returns.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], [])),
@@ -487,7 +481,6 @@ export function getProcessVariableSuggestionsAll(node: ProcessElement) {
             name: processElem.name,
             value: processElem.name,
             icon: processElem.type,
-            noFurther: true,
             children: processElem.variables.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
         });
         scopeVariable.expanded = true;
@@ -501,7 +494,6 @@ export function getProcessVariableSuggestionsAll(node: ProcessElement) {
             name: processElem.name,
             value: processElem.name,
             icon: processElem.type,
-            noFurther: true,
             children: processElem.constants.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
         });
         scopeVariable.expanded = true;
@@ -514,7 +506,6 @@ export function getProcessVariableSuggestionsAll(node: ProcessElement) {
             name: processElem.name,
             value: processElem.name,
             icon: processElem.type,
-            noFurther: true,
             children: [
                 ...processElem.variables.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),
                 ...processElem.returns.map(node => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, processElem.name], [])),

package/src/server/naslServer.ts

@@ -1262,7 +1262,10 @@ const naslServer = {
                     }
                     // params修改 查找View不需要修改
                     // 逻辑改名，触发了在定义里面的，element定义，的值，直接掠过
-                    if (minRange.node instanceof View && (node instanceof Logic || node instanceof Param)) {
+                    /**
+                        修改枚举名 引发查找到view ，以为viewElement有一个类型，但是渲染了两次，就过滤掉找到view的 内容
+                     */
+                    if (minRange.node instanceof View && (node instanceof Logic || node instanceof Param || node instanceof Enum)) {
                         /**
                          * 这里过滤一下，一些查找引用，重复的内容，直接屏蔽掉，防止操作重复
                          * 因为在生成的时候 ，可能弄了一些副作用的引用
@@ -1492,7 +1495,7 @@ const naslServer = {
      * @returns 当前节点，最后输出所有节点
      */
     _recursionCreateResult(root: QuoteNode, map: Map<QuoteNode, Array<QuoteNode>>) {
-        const children = map.get(root).map((item: QuoteNode) => naslServer._recursionCreateResult(item, map));
+        const children = (map.get(root) || []).map((item: QuoteNode) => naslServer._recursionCreateResult(item, map));
         if (children && children.length) {
             root.children = children;
         }

package/src/templator/genQueryComponent.ts

@@ -251,14 +251,6 @@ export async function joinEntity(callQueryComponent: CallQueryComponent, entity:
                 propertyName: joinInfo.rightProperty.name,
             }),
         }));
-        const structureProperty = StructureProperty.from(NaslNode.StructureProperty({
-            name: utils.firstLowerCase(entity.name),
-            typeAnnotation: NaslTypeAnnotation.Reference({
-                typeNamespace: entity.getNamespace(),
-                typeName: entity.name,
-            }),
-        }), recordStructure, 'properties');
-        recordStructure.addProperty(structureProperty);
     } else {
         queryJoinExpression.onExpressions.push(NaslLogicItem.BinaryExpression({
             operator: '==',
@@ -274,6 +266,14 @@ export async function joinEntity(callQueryComponent: CallQueryComponent, entity:
             }),
         }));
     }
+    const structureProperty = StructureProperty.from(NaslNode.StructureProperty({
+        name: utils.firstLowerCase(entity.name),
+        typeAnnotation: NaslTypeAnnotation.Reference({
+            typeNamespace: entity.getNamespace(),
+            typeName: entity.name,
+        }),
+    }), recordStructure, 'properties');
+    recordStructure.addProperty(structureProperty);
     const newJoinPartLogicItem = QueryJoinExpression.from(queryJoinExpression, callQueryComponent, 'joinParts');
     from.addJoinPart(newJoinPartLogicItem);
     callQueryComponent.saveStructure();