@lcap/nasl 3.8.0-beta.3 → 3.8.0-beta.5

package/src/natural/index.ts

@@ -2,3 +2,4 @@ export * from './genNaturalTS';
 export * from './transformTSCode';
 export * from './transformTS2UI';
 export * from './getContext/getUILib';
+export * from './tools';

package/src/natural/tools.ts

@@ -0,0 +1,130 @@
+import { App, BaseNode } from "src/concepts";
+import * as utils from '../utils';
+
+// 获取当前逻辑的类型
+export const getLogicType = (activeLogic: any) => {
+  const { parentNode } = activeLogic || {};
+  let logicType = 'global_logic';
+  if (parentNode?.concept === 'View') {
+    logicType = 'view_logic';
+  } else if (parentNode?.concept === 'BindEvent') {
+    logicType = 'event_logic';
+  }
+  if (activeLogic?.concept === 'BusinessLogic') {
+    logicType = 'business_Logic';
+  }
+  return logicType;
+};
+
+// 获取所有未使用的 module
+export const getUsedModule = (json: BaseNode) => {
+  const useModule = [] as any;
+  const conceptMap = ['CallInterface', 'CallConnector', 'CallLogic'];
+  utils.traverse(({ node }: { node: any; }) => {
+    if (conceptMap.includes(node.concept)) {
+      if (/(apis\.|connector\.|extensions\.)/.test(node.calleeNamespace)) {
+        const symbol = node.calleeNamespace.match(/(\w+)(?=\.)|(\w+$)/g)[1];
+        const item = {
+          symbol,
+          key: symbol,
+          node,
+        } as any;
+        useModule.push(item);
+      }
+    }
+    if (node.concept === 'ViewElement') {
+      const symbol = utils.kebab2Camel(node.tag);
+      const item = {
+        symbol,
+        key: symbol,
+        node,
+      } as any;
+      useModule.push(item);
+    }
+  }, { node: json }, { mode: 'anyObject' });
+  return useModule;
+};
+
+
+/**
+ * 根据生成的 NASL JSON，获取未导入的模块
+ * @param json: 当前生成的 NASL JSON
+ * @param app: 当前应用
+ * @param material: 召回的所有 Module
+ * @returns 需要导入的所有 Module 信息，包含 category、symbol、version
+ */
+export const getUnImportedModulesForLogic = (json: BaseNode, app: App, material: any) => {
+  const useModule = getUsedModule(json);
+  const needImportModule = {
+    interfaces: new Map(),
+    connectors: new Map(),
+    library: new Map(),
+    extensionMaterials: new Map(),
+    needImportConnector: false
+  } as any;
+
+  useModule.forEach((item: any) => {
+    if (item.node.concept === 'CallInterface') {
+      // 从app.interfaceDependencies中找到对应的接口
+      const interfaceNode = app.interfaceDependencies.find((node: any) => node.name === item.symbol);
+      if (!interfaceNode) {
+        item.category = 'interface';
+        const key = `${item.symbol}-${item?.node?.calleeName}`;
+        item.key = key;
+        needImportModule.interfaces.set(key, item);
+      }
+    } else if (item.node.concept === 'CallConnector') {
+      item.category = 'connector';
+      const connectorNode = app.connectorDependencies.find((node: any) => node.name === item.symbol);
+
+      // 如果 连接器 不存在，则需要导入并初始化连接
+      if (!connectorNode) {
+        item.operator = 'importAndInit';
+        item.version = material?.connectors.find((node: any) => node.name === item.symbol).version;
+        needImportModule.needImportConnector = true;
+      } else {
+        item.version = connectorNode.version;
+        // 查找连接
+        const connection = app.connections.find((conn: any) => conn.connector.name === item.symbol);
+        // 如果 连接器 已存在，且连接已经被初始化过，需要修改生成 logic 中的名字，utils.traverse 修改
+        // 如果 连接器 已存在，且连接未被初始化过，则需要初始化连接
+        if (connection) {
+          item.operator = 'rename';
+          item.rename = { newName: connection.name, oldName: item.node.calleeConnectionName };
+        } else {
+          item.operator = 'init';
+        }
+      }
+
+      needImportModule.connectors.set(item.symbol, item);
+    } else if (item.node.concept === 'CallLogic') {
+      // 从app.logicDependencies中找到对应的逻辑
+      item.category = 'library';
+      const logicNode = app.dependencies.find((node: any) => node.name === item.symbol);
+      if (!logicNode) {
+        item.version = material?.dependencies.find((node: any) => node.name === item.symbol).version;
+        needImportModule.library.set(item.symbol, item);
+      }
+    } else if (item.node.concept === 'ViewElement') {
+      const name = utils.kebab2Camel(item.node.tag);
+      const module = material?.extensionMaterials.find((node: any) => utils.kebab2Camel(node.name) === name);
+      const imported = app.dependencies.find((node: any) => node.name === module?.libraryName);
+      if (module && module.libraryName && !imported) {
+        const { libraryName } = module;
+        item.category = 'library';
+        item.key = `${libraryName}-${name}`;
+        item.symbol = libraryName;
+        item.version = material?.dependencies.find((node: any) => node.name === libraryName).version;
+        needImportModule.extensionMaterials.set(name, item);
+      }
+    }
+  });
+
+  needImportModule.interfaces = Array.from(needImportModule.interfaces.values());
+  needImportModule.connectors = Array.from(needImportModule.connectors.values());
+  needImportModule.library = Array.from(needImportModule.library.values());
+  needImportModule.extensionMaterials = Array.from(needImportModule.extensionMaterials.values());
+
+  return needImportModule;
+};
+

package/src/natural/transformTS2UI.ts

@@ -19,6 +19,13 @@ function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
     return [...flatMemberExpression(node.object), node.property];
   return [node];
 }
+
+function flatMembers(node: naslTypes.MemberExpression): Array<naslTypes.MemberExpression> {
+  if (node.concept === 'MemberExpression')
+    return [...flatMembers(((node as any)?.object)), node];
+  return [];
+}
+
 function flatMatchPatternsExpression(node: any): Array<babelTypes.Node> {
   if (node.concept === 'BinaryExpression') {
     if (node.operator === '||') {
@@ -65,6 +72,13 @@ function transformTypeAnnotation(node: babelTypes.TSType): naslTypes.TypeAnnotat
         typeNamespace: (node as any).typeNamespace,
       });
     }
+
+    if (['ValidateResult', 'ValidateEvent'].includes(typeName)) {
+      return naslTypes.TypeAnnotation.createReference(typeName, {
+        typeNamespace: 'nasl.ui'
+      });
+    }
+
     if (typeName === 'Any' || typeName === 'any') {
       return undefined;
     }
@@ -89,7 +103,7 @@ function transformTypeAnnotation(node: babelTypes.TSType): naslTypes.TypeAnnotat
       if (node?.typeName?.type === 'TSQualifiedName') {
         const allTypeName = generate(node?.typeName?.left as any)?.code;
         // 实体、枚举、结构体
-        if (/^app.dataSources|.enums|.structures/.test(allTypeName)) {
+        if (/^app.dataSources|.enums|.structures|nasl.ui/.test(allTypeName)) {
           const curTypeName = (node?.typeName as any)?.right?.name;
           return naslTypes.TypeAnnotation.createReference(curTypeName, {
             typeNamespace: allTypeName,
@@ -127,6 +141,8 @@ function transformTypeAnnotation(node: babelTypes.TSType): naslTypes.TypeAnnotat
 // 处理参数
 function transformParam(node: babelTypes.Identifier): naslTypes.Param {
   const typeAnnotation = (node.typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
+  const exclude = ['event'];
+  if (exclude.includes(node.name)) return null;
   return new naslTypes.Param({
     name: node.name,
     typeAnnotation: typeAnnotation ? transformTypeAnnotation(typeAnnotation) : null,
@@ -219,14 +235,29 @@ function handleNewExpression(calleeName: String, node: any, type?: string) {
     const assignmentLines: any = [];
     node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
       properties.push(transformNode2Expression(arg.key));
-      rights.push(new naslTypes.SelectMembers({
-        expression: transformNode2Expression(arg.value)
-      }));
-      if (arg?.value) {
-        assignmentLines.push(new naslTypes.AssignmentLine({
-          leftIndex: [0, index],
-          rightIndex: [index],
+      if (arg.value.type === 'MemberExpression') {
+        const expression = flatMemberExpression(arg.value);
+        const members = flatMembers(transformNode2Expression(arg.value) as any);
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(expression[0]),
+          members,
         }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index, index],
+          }));
+        }
+      } else {
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(arg.value)
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index],
+          }));
+        }
       }
     });
     const parameters = node?.typeParameters?.params?.[0] || {};
@@ -261,14 +292,29 @@ function handleNewExpression(calleeName: String, node: any, type?: string) {
     const assignmentLines: any = [];
     node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
       properties.push(transformNode2Expression(arg.key));
-      rights.push(new naslTypes.SelectMembers({
-        expression: transformNode2Expression(arg.value)
-      }));
-      if (arg?.value) {
-        assignmentLines.push(new naslTypes.AssignmentLine({
-          leftIndex: [0, index],
-          rightIndex: [index],
+      if (arg.value.type === 'MemberExpression') {
+        const expression = flatMemberExpression(arg.value);
+        const members = flatMembers(transformNode2Expression(arg.value) as any);
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(expression[0]),
+          members,
         }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index, index],
+          }));
+        }
+      } else {
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(arg.value)
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index],
+          }));
+        }
       }
     });
     const parameters = node?.typeParameters?.params?.[0] || {};
@@ -304,14 +350,29 @@ function handleNewExpression(calleeName: String, node: any, type?: string) {
     const assignmentLines: any = [];
     node?.arguments?.[0]?.properties?.forEach((arg: any, index: number) => {
       properties.push(transformNode2Expression(arg.key));
-      rights.push(new naslTypes.SelectMembers({
-        expression: transformNode2Expression(arg.value)
-      }));
-      if (arg?.value) {
-        assignmentLines.push(new naslTypes.AssignmentLine({
-          leftIndex: [0, index],
-          rightIndex: [index],
+      if (arg.value.type === 'MemberExpression') {
+        const expression = flatMemberExpression(arg.value);
+        const members = flatMembers(transformNode2Expression(arg.value) as any);
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(expression[0]),
+          members,
         }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index, index],
+          }));
+        }
+      } else {
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(arg.value)
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index],
+          }));
+        }
       }
       structureProperties.push(new naslTypes.StructureProperty({
         name: arg?.key?.name,
@@ -1187,6 +1248,7 @@ function transformNode2View(node: babelTypes.FunctionDeclaration, root?: ParseRe
     if (item.type === 'ReturnStatement' && item?.argument?.type === 'ArrayExpression') {
       viewItem?.forEach((element: any) => {
         json.push(element.aiParams);
+        view.addViewElement(element);
       });
     }
     if (viewItem?.concept === 'Variable') {

package/src/natural/transformTSCode.ts

@@ -29,6 +29,13 @@ function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
     return [...flatMemberExpression(node.object), node.property];
   return [node];
 }
+
+function flatMembers(node: naslTypes.MemberExpression): Array<naslTypes.MemberExpression> {
+  if (node.concept === 'MemberExpression')
+    return [...flatMembers(((node as any)?.object)), node];
+  return [];
+}
+
 function flatMatchPatternsExpression(node: any): Array<babelTypes.Node> {
   if (node.concept === 'BinaryExpression') {
     if (node.operator === '||') {
@@ -79,6 +86,13 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           typeNamespace: (node as any).typeNamespace,
         });
       }
+
+      if (['ValidateResult', 'ValidateEvent'].includes(typeName)) {
+        return naslTypes.TypeAnnotation.createReference(typeName, {
+          typeNamespace: 'nasl.ui'
+        });
+      }
+
       if (typeName === 'Any' || typeName === 'any') {
         return undefined;
       }
@@ -103,7 +117,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         if (node?.typeName?.type === 'TSQualifiedName') {
           const allTypeName = generate(node?.typeName?.left as any)?.code;
           // 实体、枚举、结构体
-          if (/^app.dataSources|.enums|.structures/.test(allTypeName)) {
+          if (/^app.dataSources|.enums|.structures|nasl.ui/.test(allTypeName)) {
             const curTypeName = (node?.typeName as any)?.right?.name;
             return naslTypes.TypeAnnotation.createReference(curTypeName, {
               typeNamespace: allTypeName,
@@ -139,6 +153,8 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
   }
   function transformParam(node: babelTypes.Identifier): naslTypes.Param {
     const typeAnnotation = (node.typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
+    const exclude = ['event'];
+    if (exclude.includes(node.name)) return null;
     return new naslTypes.Param({
       name: node.name,
       typeAnnotation: typeAnnotation ? transformTypeAnnotation(typeAnnotation) : null,
@@ -204,14 +220,29 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       const assignmentLines: any = [];
       node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
         properties.push(transformLogicNode(arg.key));
-        rights.push(new naslTypes.SelectMembers({
-          expression: transformLogicNode(arg.value)
-        }));
-        if (arg?.value) {
-          assignmentLines.push(new naslTypes.AssignmentLine({
-            leftIndex: [0, index],
-            rightIndex: [index],
+        if (arg.value.type === 'MemberExpression') {
+          const expression = flatMemberExpression(arg.value);
+          const members = flatMembers(transformLogicNode(arg.value) as any);
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(expression[0]),
+            members,
+          }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index, index],
+            }));
+          }
+        } else {
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(arg.value)
           }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index],
+            }));
+          }
         }
       });
       const parameters = node?.typeParameters?.params?.[0] || {};
@@ -246,14 +277,29 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       const assignmentLines: any = [];
       node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
         properties.push(transformLogicNode(arg.key));
-        rights.push(new naslTypes.SelectMembers({
-          expression: transformLogicNode(arg.value)
-        }));
-        if (arg?.value) {
-          assignmentLines.push(new naslTypes.AssignmentLine({
-            leftIndex: [0, index],
-            rightIndex: [index],
+        if (arg.value.type === 'MemberExpression') {
+          const expression = flatMemberExpression(arg.value);
+          const members = flatMembers(transformLogicNode(arg.value) as any);
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(expression[0]),
+            members,
+          }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index, index],
+            }));
+          }
+        } else {
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(arg.value)
           }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index],
+            }));
+          }
         }
       });
       const parameters = node?.typeParameters?.params?.[0] || {};
@@ -289,14 +335,29 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       const assignmentLines: any = [];
       node?.arguments?.[0]?.properties?.forEach((arg: any, index: number) => {
         properties.push(transformLogicNode(arg.key));
-        rights.push(new naslTypes.SelectMembers({
-          expression: transformLogicNode(arg.value)
-        }));
-        if (arg?.value) {
-          assignmentLines.push(new naslTypes.AssignmentLine({
-            leftIndex: [0, index],
-            rightIndex: [index],
+        if (arg.value.type === 'MemberExpression') {
+          const expression = flatMemberExpression(arg.value);
+          const members = flatMembers(transformLogicNode(arg.value) as any);
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(expression[0]),
+            members,
           }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index, index],
+            }));
+          }
+        } else {
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(arg.value)
+          }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index],
+            }));
+          }
         }
         structureProperties.push(new naslTypes.StructureProperty({
           name: arg?.key?.name,

package/src/server/formatTsUtils.ts

@@ -23,6 +23,7 @@ import {
   BusinessLogic,
   View,
   Enum,
+  SubLogic
 } from '..';
 import { getNaslNodeByNodeCallee } from '../automate/engine/utils';
 import { runGeneratorSync as runSync, getAncestorExistingParamNames } from '../utils';
@@ -701,6 +702,19 @@ function getNodeiconFromLogic(completionProperty: CompletionProperty, node: type
   const likeComponent = node.getAncestor('View') as View || node.getAncestor('BusinessComponent') as BusinessComponent;
   const logic = (node as Param).logic || node.getAncestor('BusinessLogic') as BusinessLogic || (node as Param).OverriddenLogic || (node as Param).AuthLogic || (node as Param).AuthLogicForCallInterface;
 
+  // 如果节点存在于SubLogic 中，则可能出现 SubLogic 嵌套 SubLogic 的情况
+  // 为此需要找全链路上的所有 SubLogic 及其对应的参数
+  let parentSubLogicNode = node.getAncestor('SubLogic');
+  const isInSubLogic = !!parentSubLogicNode;
+  const logicLikeList: (SubLogic | Logic)[] = [];
+  if (isInSubLogic) {
+    while(parentSubLogicNode) {
+      logicLikeList.push(parentSubLogicNode as SubLogic);
+      parentSubLogicNode = parentSubLogicNode.getAncestor('SubLogic');
+    }
+    logicLikeList.push(logic);
+  }
+
   if (node.concept === 'Identifier' || node.concept === 'BindAttribute' || node.concept === 'MemberExpression') {
     const ancestorParamNames = getAncestorExistingParamNames(node);
     if (ancestorParamNames.has(propName)) {
@@ -718,7 +732,13 @@ function getNodeiconFromLogic(completionProperty: CompletionProperty, node: type
 
   if (logic) {
     const { returns } = logic;
-    const params: Param[] = logic.params;
+
+    let params: Param[] = logic.params;
+    if (isInSubLogic) {
+      // 保证局部作用域的变量优先级高于全局作用域
+      params = logicLikeList.reduce((acc, cur) => acc.concat(cur.params), []);
+    }
+
     if (logic instanceof AuthLogicForCallInterface) {
       const { authParams } = logic;
       if (authParams.find((item) => item.name === completionProperty.name)) return 'api-auth-params';

package/src/server/getLogics.ts

@@ -511,12 +511,9 @@ export function getLogicsSync(node: CallLogic | BindEvent | Identifier | Logic,
     return result;
   }
   if (node?.concept === 'Identifier') {
-    // 之前 连接器 Connector 相关也存在与 app.dependencies 下，
-    // 现在迁移到 app.connectorDependencies 下，
-    // 为保证上下游逻辑与之前保持一致，这边做相应的扩展
     const extensions = [
       ...app.dependencies,
-      ...(app.connectorDependencies || [])
+      // ...(app.connectorDependencies || [])
     ]
       .map((dep) => moduleToLogicNamesapce(dep, app.overriddenLogics))
       .filter((item) => item.logics && item.logics.length);