@lcap/nasl 3.8.2-beta.8 → 3.8.3-beta.1

package/src/natural/transforms/transform2LogicItem.ts

@@ -0,0 +1,1335 @@
+import { babelTypes, naslTypes, generate, DEBUG, throwError, tryParseTS } from './utils';
+import { transform2TypeAnnotation } from './transform2TypeAnnotation';
+import { firstUpperCase } from '../../utils';
+
+export interface TransformOptions {
+  logic: naslTypes.Logic,
+  isPageLogic: boolean,
+  entityAsNames?: Array<string>,
+  typeAnnotation?: naslTypes.TypeAnnotation,
+}
+
+export type TransformPair<B extends babelTypes.Node, N extends naslTypes.LogicItem> = [
+  B['type'] | ((node: B) => boolean),
+  (node: B, options: TransformOptions) => N
+];
+export type TransformCallExpressionPair = [
+  string | ((node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[]) => boolean),
+  (node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions) => naslTypes.LogicItem
+];
+
+export class TransformManager {
+  private transforms: Array<TransformPair<babelTypes.Node, naslTypes.LogicItem>> = [];
+  private transformCallExpressions: Array<TransformCallExpressionPair> = [];
+
+  register<B extends babelTypes.Node, N extends naslTypes.LogicItem>(type: TransformPair<B, N>[0], transform: TransformPair<B, N>[1]) {
+    this.transforms.push([type, transform]);
+  }
+  registerCallExpression(type: TransformCallExpressionPair[0], transform: TransformCallExpressionPair[1]) {
+    this.transformCallExpressions.push([type, transform]);
+  }
+
+  apply(node: babelTypes.Node, options: TransformOptions) {
+    if (node.type === 'CallExpression' && node.callee.type !== 'CallExpression') {
+      const callee = flatMemberExpression(node.callee);
+      const calleeName = generate(node.callee as any).code;
+      for (const [type, transform] of this.transformCallExpressions) {
+        if (typeof type === 'function' ? type(node, calleeName, callee) : type === calleeName) {
+          return transform(node, calleeName, callee, options);
+        }
+      }
+      throwError(`Unhandled node ${callee.map((item: babelTypes.Identifier) => item.name).join('.')} ${node.type}`);
+    } else {
+      for (const [type, transform] of this.transforms) {
+        if (typeof type === 'function' ? type(node) : type === node.type) {
+          return transform(node, options);
+        }
+      }
+      throwError(`Unhandled node ${node.type}`);
+    }
+  }
+}
+
+function fixExpression(arg: any, options: TransformOptions) {
+  let expression = transform2LogicItem(arg, options);
+  if (expression?.concept === 'Identifier' && expression?.name === 'undefined') {
+    expression = undefined;
+  }
+  return expression;
+}
+
+/**
+ * 铺平点选表达式
+ */
+function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
+  if (node.type === 'MemberExpression')
+    return [...flatMemberExpression(node.object), node.property];
+  return [node];
+}
+
+/**
+ * 铺平链式调用表达式
+ */
+function flatChainCallExpression(node: babelTypes.CallExpression): Array<babelTypes.CallExpression> {
+  if (node.callee.type === 'MemberExpression') {
+    if (node.callee.object.type === 'CallExpression' && node.callee.property.type === 'Identifier')
+      return [...flatChainCallExpression(node.callee.object), babelTypes.callExpression(node.callee.property, node.arguments)];
+    else if (node.callee.object.type === 'Identifier' && node.callee.property.type === 'Identifier')
+      return [babelTypes.callExpression(node.callee.property, node.arguments)];
+  }
+  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 === '||') {
+      return [...flatMatchPatternsExpression(node.left), ...flatMatchPatternsExpression(node.right)];
+    }
+    if (node.operator === '==') {
+      return [node.right];
+    }
+    return [node];
+  }
+  return [node];
+}
+
+function flatIfStatement(node: any): Array<babelTypes.Node> {
+  if (node.alternate.type === 'IfStatement') {
+    return [...flatIfStatement(node.alternate), node];
+  }
+  return [node];
+}
+
+
+/**
+ * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
+ * @param node
+ * @returns
+ */
+function fixLogicNode(node: babelTypes.Node): void {
+  if (node?.type === 'CallExpression') {
+    const calleeName = generate(node.callee as any).code;
+    if (calleeName === 'nasl.util.ForEach') {
+      const callee = flatMemberExpression(node.callee);
+      node.callee = callee[2] as babelTypes.Identifier;
+    }
+  }
+}
+
+export function transform2Param(node: babelTypes.Identifier): naslTypes.Param {
+  const typeAnnotation = (node.typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
+  return new naslTypes.Param({
+    name: node.name,
+    typeAnnotation: typeAnnotation ? transform2TypeAnnotation(typeAnnotation) : null,
+  });
+}
+
+function transformCallExpressionToBinaryExpression(node: babelTypes.CallExpression, calleeName: String, callee: babelTypes.Node[], options: TransformOptions) {
+  const argument = node?.arguments;
+  const map = {
+    plus: '+',
+    minus: '-',
+    multiply: '*',
+    divide: '/',
+    remainder: '%',
+    STARTWITH: 'startwith',
+    ENDWITH: 'endwith',
+    LIKE: 'like',
+    IN: 'in',
+  };
+  return new naslTypes.BinaryExpression({
+    operator: map[calleeName as keyof typeof map] as naslTypes.BinaryExpression['operator'],
+    left: transform2LogicItem(argument?.[0], options),
+    right: transform2LogicItem(argument?.[1], options),
+  });
+}
+
+function transform2BinaryExpression(node: babelTypes.BinaryExpression | babelTypes.LogicalExpression, options: TransformOptions): naslTypes.BinaryExpression {
+  if (node.operator === '===')
+    node.operator = '==';
+  if (node.operator === '!==')
+    node.operator = '!=';
+  if (['+', '-', '*', '/', '%', '==', '!=', '>', '<', '>=', '<=', '&&', '||', 'startwith', 'endwith', 'like', 'in'].includes(node.operator)) {
+    return new naslTypes.BinaryExpression({
+      operator: node.operator as any,
+      left: transform2LogicItem(node.left, options),
+      right: transform2LogicItem(node.right, options),
+    });
+  }
+  throwError(`Unhandled node ${node.type}`);
+}
+
+
+function transform2NewExpression(calleeName: String, node: babelTypes.CallExpression, options: TransformOptions) {
+  if (calleeName === 'NewList') {
+    return new naslTypes.NewList({
+      typeAnnotation: naslTypes.TypeAnnotation.createGeneric('List', {
+        typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation),
+      }),
+      items: (node?.arguments?.[0] as babelTypes.ArrayExpression).elements?.map((arg: any) => transform2LogicItem(arg, options)),
+    });
+  }
+  if (calleeName === 'NewMap') {
+    const keys: any = [];
+    const values: any = [];
+    (node?.arguments?.[0] as babelTypes.ObjectExpression)?.properties.forEach((arg: any) => {
+      keys.push(transform2LogicItem(arg.key, options));
+      values.push(transform2LogicItem(arg.value, options));
+    });
+    return new naslTypes.NewMap({
+      typeAnnotation: naslTypes.TypeAnnotation.createGeneric('Map', {
+        typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation),
+      }),
+      keys,
+      values,
+    });
+  }
+  if (calleeName === 'NewEntity') {
+    const properties: any = [];
+    const rights: any = [];
+    const assignmentLines: any = [];
+    (node?.arguments?.[0] as babelTypes.ObjectExpression)?.properties.forEach((arg: any, index: number) => {
+      properties.push(transform2LogicItem(arg.key, options));
+      if (arg.value.type === 'MemberExpression') {
+        const expression = flatMemberExpression(arg.value);
+        const members = flatMembers(transform2LogicItem(arg.value, options) as any);
+        rights.push(new naslTypes.SelectMembers({
+          expression: transform2LogicItem(expression[0], options),
+          members,
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index, index],
+          }));
+        }
+      } else {
+        rights.push(new naslTypes.SelectMembers({
+          expression: transform2LogicItem(arg.value, options)
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index],
+          }));
+        }
+      }
+    });
+    const parameters = node?.typeParameters?.params?.[0] as babelTypes.TSTypeReference;
+    if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
+      const { left, right } = parameters?.typeName || {};
+      const typeNamespace = generate(left as any)?.code;
+      const typeName = right?.name;
+      return new naslTypes.NewComposite({
+        typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+          typeNamespace,
+          typeName
+        }),
+        properties,
+        rights,
+        assignmentLines
+      });
+    }
+    const typeName = (parameters?.typeName as babelTypes.Identifier)?.name;
+    return new naslTypes.NewComposite({
+      typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+        typeNamespace: 'app.dataSources.defaultDS.entities',
+        typeName
+      }),
+      properties,
+      rights,
+      assignmentLines
+    });
+  }
+  if (calleeName === 'NewStructure') {
+    const properties: any = [];
+    const rights: any = [];
+    const assignmentLines: any = [];
+    (node?.arguments?.[0] as babelTypes.ObjectExpression)?.properties.forEach((arg: any, index: number) => {
+      properties.push(transform2LogicItem(arg.key, options));
+      if (arg.value.type === 'MemberExpression') {
+        const expression = flatMemberExpression(arg.value);
+        const members = flatMembers(transform2LogicItem(arg.value, options) as any);
+        rights.push(new naslTypes.SelectMembers({
+          expression: transform2LogicItem(expression[0], options),
+          members,
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index, index],
+          }));
+        }
+      } else {
+        rights.push(new naslTypes.SelectMembers({
+          expression: transform2LogicItem(arg.value, options)
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index],
+          }));
+        }
+      }
+    });
+    const parameters = node?.typeParameters?.params?.[0] as babelTypes.TSTypeReference;
+    if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
+      const { left, right } = parameters?.typeName || {};
+      const typeNamespace = generate(left as any)?.code;
+      const typeName = right?.name;
+      return new naslTypes.NewComposite({
+        typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+          typeNamespace,
+          typeName
+        }),
+        properties,
+        rights,
+        assignmentLines
+      });
+    }
+    const typeName = (parameters?.typeName as babelTypes.Identifier)?.name;
+    return new naslTypes.NewComposite({
+      typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+        typeNamespace: 'app.structures',
+        typeName
+      }),
+      properties,
+      rights,
+      assignmentLines
+    });
+  }
+  if (calleeName === 'NewAnonymousStructure') {
+    const properties: any = [];
+    const rights: any = [];
+    const structureProperties: any = [];
+    const assignmentLines: any = [];
+    (node?.arguments?.[0] as babelTypes.ObjectExpression)?.properties?.forEach((arg: any, index: number) => {
+      properties.push(transform2LogicItem(arg.key, options));
+      if (arg.value.type === 'MemberExpression') {
+        const expression = flatMemberExpression(arg.value);
+        const members = flatMembers(transform2LogicItem(arg.value, options) as any);
+        rights.push(new naslTypes.SelectMembers({
+          expression: transform2LogicItem(expression[0], options),
+          members,
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index, index],
+          }));
+        }
+      } else {
+        rights.push(new naslTypes.SelectMembers({
+          expression: transform2LogicItem(arg.value, options)
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index],
+          }));
+        }
+      }
+      structureProperties.push(new naslTypes.StructureProperty({
+        name: arg?.key?.name,
+        typeAnnotation: null
+      }));
+    });
+    return new naslTypes.NewComposite({
+      typeAnnotation: naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
+      properties,
+      rights,
+      assignmentLines
+    });
+  }
+  throwError(`Unhandled ArrowFunctionExpression node ${node.type}`);
+}
+
+function pushElseIf(ifNode: babelTypes.IfStatement, switchStatement: naslTypes.SwitchStatement, options: TransformOptions) {
+  switchStatement.cases.push(new naslTypes.SwitchCase({
+    test: transform2LogicItem(ifNode.test, options),
+    consequent: !ifNode.consequent ? [] : (ifNode.consequent as babelTypes.BlockStatement).body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+  }));
+  if (ifNode.alternate && ifNode.alternate.type === 'IfStatement') {
+    pushElseIf(ifNode.alternate, switchStatement, options);
+  } else {
+    switchStatement.cases.push(new naslTypes.SwitchCase({
+      test: undefined,
+      consequent: !ifNode?.alternate ? [] : (ifNode?.alternate as babelTypes.BlockStatement)?.body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+    }));
+  }
+}
+
+function transform2VariableAndAddAssignment(node: babelTypes.VariableDeclaration, options: TransformOptions): naslTypes.Assignment {
+  const declList = node?.declarations || [];
+  let newNode: naslTypes.Assignment;
+  declList?.forEach((decl) => {
+    const variableName = (decl.id as babelTypes.Identifier).name;
+    if (![...options.logic.variables, ...options.logic.returns].some((variable) => variable.name === variableName)) {
+      const varTypeAnnotation = ((decl.id as babelTypes.Identifier).typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
+      options.logic.variables.push(new naslTypes.Variable({
+        name: variableName,
+        typeAnnotation: varTypeAnnotation && transform2TypeAnnotation(varTypeAnnotation),
+      }));
+    }
+    if (decl.init) {
+      if (decl.init.type !== 'ArrayExpression' && decl.init.type !== 'ObjectExpression') {
+        const calleeName = generate((decl?.init as any)?.callee).code;
+        const varTypeAnnotation = ((decl?.id as babelTypes.Identifier)?.typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
+        if (calleeName === 'nasl.oql.query' && varTypeAnnotation) {
+          (decl.init as any).typeAnnotations = varTypeAnnotation;
+        }
+        newNode = new naslTypes.Assignment({
+          left: new naslTypes.Identifier({
+            name: variableName,
+          }),
+          right: transform2LogicItem(decl.init, options),
+        });
+      }
+    }
+  });
+  if (newNode) return newNode;
+}
+
+function transform2IfStatement(node: babelTypes.IfStatement, options: TransformOptions): naslTypes.SwitchStatement | naslTypes.IfStatement {
+  if (node.alternate && node.alternate.type === 'IfStatement') {
+    const switchStatement = new naslTypes.SwitchStatement({
+      cases: [],
+    });
+    pushElseIf(node, switchStatement, options);
+    return switchStatement;
+  }
+  let consequentIndex: number;
+  let alternateIndex: number;
+  const naslNode = new naslTypes.IfStatement({
+    test: transform2LogicItem(node.test, options),
+    consequent: !node.consequent ? [] : (node.consequent as babelTypes.BlockStatement).body.map((item: any, index: number) => {
+      if (item?.type === 'ReturnStatement') {
+        item.ends = true;
+        if (item?.argument) {
+          consequentIndex = index;
+        }
+      }
+      return transform2LogicItem(item, options);
+    }).filter((item) => !!item),
+    alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map((item: any, index: number) => {
+      if (item?.type === 'ReturnStatement') {
+        item.ends = true;
+        if (item?.argument) {
+          alternateIndex = index;
+        }
+      }
+      return transform2LogicItem(item, options);
+    }).filter((item) => !!item),
+  }) as any;
+  if (consequentIndex !== undefined) {
+    naslNode?.consequent?.splice(consequentIndex + 1, 0, new naslTypes.End());
+  }
+  if (alternateIndex !== undefined) {
+    naslNode?.alternate?.splice(alternateIndex + 1, 0, new naslTypes.End());
+  }
+  return naslNode;
+}
+
+function transform2WhileStatement(node: babelTypes.WhileStatement, options: TransformOptions): naslTypes.WhileStatement {
+  return new naslTypes.WhileStatement({
+    test: transform2LogicItem(node.test, options),
+    body: (node.body as babelTypes.BlockStatement).body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+  });
+}
+
+function transformSwitchStatement2Match(node: babelTypes.SwitchStatement, options: TransformOptions): naslTypes.Match {
+  const match = new naslTypes.Match({
+    expression: transform2LogicItem(node.discriminant, options),
+    isExpression: false,
+    cases: node.cases.map((_case) => new naslTypes.MatchCase({
+      patterns: !_case.test ? [] : [transform2LogicItem(_case.test, options)],
+      body: _case.consequent.filter((item) => item.type !== 'BreakStatement').map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+    })),
+  });
+  if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
+    match.cases.push(new naslTypes.MatchCase({
+      patterns: [],
+      body: [],
+    }));
+  }
+  match.cases.forEach((case_: any) => {
+    if (case_.body.length && (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
+      case_.isMatchedTypeEnumable = true;
+    }
+    if (case_.patterns.length && case_.patterns[0].concept === 'MemberExpression') {
+      case_.isMatchedTypeEnumable = true;
+      case_.patterns[0].object.namespace = 'app.enums';
+    }
+  });
+  return match;
+}
+
+function transformIdentifier(node: babelTypes.Identifier, options: TransformOptions): naslTypes.QueryFieldExpression | naslTypes.Identifier {
+  if (options.entityAsNames?.includes(node.name)) {
+    return new naslTypes.QueryFieldExpression({
+      isDotStar: false,
+      asName: undefined,
+      entityAsName: node.name,
+      propertyName: '',
+    });
+  }
+
+  return new naslTypes.Identifier({
+    name: node.name,
+  });
+}
+
+function transform2SelectQueryFieldExpression(node: babelTypes.ObjectProperty, options: TransformOptions): naslTypes.QueryFieldExpression {
+  // babelTypes.Identifier | babelTypes.MemberExpression
+  let expression: babelTypes.Identifier | babelTypes.MemberExpression;
+  let asNameNode: babelTypes.Identifier;
+  // if (node.type === 'ObjectProperty') {
+  expression = node.value as babelTypes.Identifier | babelTypes.MemberExpression;
+  asNameNode = node.key as babelTypes.Identifier;
+  // }
+
+  if (expression.type === 'Identifier') {
+    return new naslTypes.QueryFieldExpression({
+      isDotStar: true,
+      asName: firstUpperCase(asNameNode.name) === expression.name ? undefined : asNameNode.name,
+      entityAsName: expression.name,
+      propertyName: '',
+    });
+  } else {
+    return new naslTypes.QueryFieldExpression({
+      isDotStar: true,
+      asName: firstUpperCase(asNameNode.name) === (expression.property as babelTypes.Identifier).name ? undefined : asNameNode.name,
+      entityAsName: (expression.object as babelTypes.Identifier).name,
+      propertyName: (expression.property as babelTypes.Identifier).name,
+    });
+  }
+}
+
+function transform2QueryAggregateExpression(node: babelTypes.ObjectProperty, options: TransformOptions): naslTypes.QueryAggregateExpression {
+  const callExpression = node.value as babelTypes.CallExpression;
+  let asNameNode: babelTypes.Identifier = node.key as babelTypes.Identifier;
+
+  const arg = callExpression.arguments[0];
+
+  return new naslTypes.QueryAggregateExpression({
+    asName: asNameNode.name,
+    aggregateName: (callExpression.callee as babelTypes.Identifier).name as 'COUNT' | 'COUNTD' | 'SUM' | 'AVG' | 'MAX' | 'MIN',
+    aggregateParam: (arg.type === 'MemberExpression' ? transformMemberExpression(arg, options) : transformIdentifier(arg as babelTypes.Identifier, options)) as naslTypes.QueryFieldExpression,
+  });
+}
+
+function transform2AnonymousFunction(node: babelTypes.ArrowFunctionExpression, options: TransformOptions): naslTypes.AnonymousFunction {
+  return new naslTypes.AnonymousFunction({
+    params: node.params.map((param: babelTypes.Identifier) => transform2Param(param)),
+    body: transform2LogicItem(node.body, options),
+  });
+}
+
+function transform2Assignment(node: babelTypes.AssignmentExpression, options: TransformOptions): naslTypes.Assignment {
+  if (node.operator === '+=' || node.operator === '-=') {
+    return new naslTypes.Assignment({
+      left: transform2LogicItem(node.left, options),
+      right: new naslTypes.BinaryExpression({
+        operator: node.operator[0] as '+' | '-',
+        left: transform2LogicItem(node.left, options),
+        right: transform2LogicItem(node.right, options),
+      }),
+    });
+  }
+  return new naslTypes.Assignment({
+    left: transform2LogicItem(node.left, options),
+    right: transform2LogicItem(node.right, options),
+  });
+}
+
+function transformUpdateExpression2Assignment(node: babelTypes.UpdateExpression, options: TransformOptions): naslTypes.Assignment {
+  if (node.operator === '++' || node.operator === '--') {
+    return new naslTypes.Assignment({
+      left: transform2LogicItem(node.argument, options),
+      right: new naslTypes.BinaryExpression({
+        operator: node.operator[0] as '+' | '-',
+        left: transform2LogicItem(node.argument, options),
+        right: new naslTypes.NumericLiteral({
+          value: '1',
+          typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Integer'),
+        }),
+      }),
+    });
+  }
+}
+
+function transform2BooleanLiteral(node: babelTypes.BooleanLiteral, options: TransformOptions): naslTypes.BooleanLiteral {
+  return new naslTypes.BooleanLiteral({
+    value: String(node.value),
+  });
+}
+
+function transform2StringLiteral(node: babelTypes.StringLiteral, options: TransformOptions): naslTypes.StringLiteral {
+  return new naslTypes.StringLiteral({
+    value: node.value,
+  });
+}
+
+function transform2NumericLiteral(node: babelTypes.NumericLiteral, options: TransformOptions): naslTypes.NumericLiteral {
+  const literal = new naslTypes.NumericLiteral({
+    value: String(node.value),
+    typeAnnotation: options.typeAnnotation || naslTypes.TypeAnnotation.createPrimitive('Integer'),
+  });
+  literal.typeAnnotation.typeName = literal.changeType(String(node.value));
+  return literal;
+}
+
+function transform2NullLiteral(node: babelTypes.NullLiteral, options: TransformOptions): naslTypes.NullLiteral {
+  return new naslTypes.NullLiteral();
+}
+
+function transformReturnStatement2AssignmentOrEnd(node: babelTypes.ReturnStatement, options: TransformOptions): naslTypes.Assignment | naslTypes.End {
+  if (!node.argument) {
+    return new naslTypes.End();
+  }
+  const { logic } = options;
+  if (node.argument?.type === 'Identifier') {
+    if (!logic.returns.length) {
+      const curVariable = logic?.variables?.find((item) => item.name === (node?.argument as any)?.name);
+      if (curVariable) {
+        logic.variables = logic?.variables?.filter((item) => item.name !== (node?.argument as any)?.name);
+        logic.addReturn(curVariable as any);
+      }
+    }
+  } else {
+    if (!logic.returns.length) {
+      logic.returns.push(new naslTypes.Return({
+        name: 'result',
+      }));
+    }
+    return new naslTypes.Assignment({
+      left: new naslTypes.Identifier({
+        name: logic.returns[0].name,
+      }),
+      right: transform2LogicItem(node.argument, options),
+    });
+  }
+}
+
+function transform2StringInterpolation(node: babelTypes.TemplateLiteral, options: TransformOptions): naslTypes.StringInterpolation {
+  const expressions = [...node.expressions as babelTypes.Expression[], ...node.quasis.map((element) => ({
+    type: 'StringLiteral',
+    value: element.value.raw,
+    start: element.start,
+    end: element.end,
+  })) as babelTypes.StringLiteral[]];
+  expressions.sort((a, b) => a.start - b.start);
+
+  return new naslTypes.StringInterpolation({
+    expressions: expressions.map((item) => transform2LogicItem(item, options)),
+  });
+}
+
+function transform2Comment(node: babelTypes.EmptyStatement, options: TransformOptions): naslTypes.Comment {
+  return node.leadingComments && new naslTypes.Comment({
+    value: String(node.leadingComments[0].value),
+  });
+}
+
+function transformBlockStatement(node: babelTypes.BlockStatement, options: TransformOptions): naslTypes.LogicItem {
+  return transform2LogicItem(node?.body?.[0], options);
+}
+
+function transform2NewComposite(node: babelTypes.ObjectExpression, options: TransformOptions): naslTypes.NewComposite {
+  const properties: any = [];
+  const rights: any = [];
+  const structureProperties: any = [];
+  const assignmentLines: any = [];
+  node?.properties?.forEach((arg: any, index: number) => {
+    properties.push(transform2LogicItem(arg.key, options));
+    rights.push(new naslTypes.SelectMembers({
+      expression: transform2LogicItem(arg?.value, options)
+    }));
+    if (arg?.value) {
+      assignmentLines.push(new naslTypes.AssignmentLine({
+        leftIndex: [0, index],
+        rightIndex: [index],
+      }));
+    }
+    structureProperties.push(new naslTypes.StructureProperty({
+      name: arg?.key?.name,
+      typeAnnotation: null
+    }));
+  });
+  return new naslTypes.NewComposite({
+    typeAnnotation: naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
+    properties,
+    rights,
+    assignmentLines
+  });
+}
+
+function transformNewExpression(node: babelTypes.NewExpression, options: TransformOptions): naslTypes.LogicItem {
+  const calleeName = generate(node.callee as any).code;
+  if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {
+    return transform2LogicItem(node.arguments[0], {
+      ...options,
+      typeAnnotation: naslTypes.TypeAnnotation.createPrimitive(calleeName),
+    });
+  }
+  throwError(`Unhandled node ${node.type}`);
+}
+
+function transformMemberExpression(node: babelTypes.MemberExpression, options: TransformOptions): naslTypes.CallFunction | naslTypes.QueryFieldExpression | naslTypes.MemberExpression | naslTypes.Identifier {
+  if (options.entityAsNames?.includes((node.object as babelTypes.Identifier).name)) {
+    return new naslTypes.QueryFieldExpression({
+      isDotStar: false,
+      asName: undefined,
+      entityAsName: (node.object as babelTypes.Identifier).name,
+      propertyName: (node.property as babelTypes.Identifier).name,
+    });
+  }
+
+  const callee = flatMemberExpression(node);
+  const calleeName = generate(node)?.code;
+  if (calleeName?.includes('app.enums')) {
+    const name = (callee?.[3] as babelTypes.StringLiteral)?.value || (callee?.[3] as babelTypes.Identifier)?.name || (callee?.[3] as babelTypes.NumericLiteral)?.value;
+    return new naslTypes.MemberExpression({
+      object: new naslTypes.Identifier({
+        namespace: 'app.enums',
+        name: (callee?.[2] as babelTypes.Identifier)?.name,
+      }),
+      property: new naslTypes.Identifier({
+        name: String(name),
+      }),
+    });
+  }
+  if (calleeName?.includes('nasl.auth.')) {
+    return new naslTypes.MemberExpression({
+      object: new naslTypes.Identifier({
+        namespace: 'nasl.auth',
+        name: (callee?.[2] as babelTypes.Identifier)?.name,
+      }),
+      property: new naslTypes.Identifier({
+        name: (callee?.[3] as babelTypes.Identifier)?.name,
+      }),
+    });
+  }
+  const regex = /^(app\..+?)\.variables\.(.+)$/;
+  if (regex.test(calleeName)) {
+    const [, namespace, variableName] = calleeName.match(regex);
+    return new naslTypes.Identifier({
+      name: String(variableName),
+      namespace: `${namespace}.variables`
+    });
+  }
+  if (node.property.type === 'NumericLiteral') {
+    return new naslTypes.CallFunction({
+      calleeNamespace: 'nasl.util',
+      calleeName: 'Get',
+      arguments: [
+        new naslTypes.Argument({
+          expression: transform2LogicItem(node.object, options),
+        }),
+        new naslTypes.Argument({
+          expression: transform2LogicItem(node.property, options),
+        }),
+      ],
+    });
+  }
+  return new naslTypes.MemberExpression({
+    object: transform2LogicItem(node.object, options),
+    property: transform2LogicItem(node.property, options),
+  });
+}
+
+function transformCallCall2Match(node: babelTypes.CallExpression, options: TransformOptions): naslTypes.Match {
+  // (function match() {})(...) 的情况
+  return undefined;
+}
+
+function transformCall2CallViewElementLogic(node: babelTypes.CallExpression, calleeNmae: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  return new naslTypes.CallLogic({
+    calleeNamespace: `elements.${(callee[1] as babelTypes.Identifier).name}.logics`,
+    calleeName: (callee[2] as babelTypes.Identifier).name,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2CallEntityLogic(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  const entityName = (callee[0] as babelTypes.Identifier).name.replace(/Entity/, '');
+  return new naslTypes.CallLogic({
+    calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
+    calleeName: (callee[1] as babelTypes.Identifier).name,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2CallDataSourceLogic(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  if (calleeName?.includes('.entities.')) {
+    const calleeNamespace = generate((node?.callee as any)?.object?.object)?.code;
+    const entityName = (node?.callee as any)?.object?.property?.name?.replace(/Entity/, '');
+    return new naslTypes.CallLogic({
+      calleeNamespace: `${calleeNamespace}.${entityName}.logics`,
+      calleeName: (node?.callee as any)?.property?.name,
+      arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+        expression: fixExpression(arg, options),
+      })) as naslTypes.Argument[],
+    });
+  }
+
+  return new naslTypes.CallLogic({
+    calleeNamespace: generate((node.callee as any).object).code,
+    calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2OQLQuery(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.OqlQueryComponent {
+  if (!options.isPageLogic) {
+    // const _typeAnnotation = node?.typeParameters?.params?.length > 0 ? naslTypes.TypeAnnotation.createGeneric('List', {
+    //   typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType })),
+    // }) : null;
+    let code = generate(node.arguments[0] as any).code.trim().slice(1, -1);
+    code = code?.replace(/app\.enums\.(\w+)\[(\d+)\]/g, "app.enums.$1.$2").replace(/app\.enums\.(\w+)\['(\w+)'\]/g, "app.enums.$1.$2");
+    return new naslTypes.OqlQueryComponent({
+      dataSource: 'app.dataSources.defaultDS',
+      code,
+      typeAnnotation: transform2TypeAnnotation((node as any)?.typeAnnotations)
+    });
+  }
+}
+
+function transformCall2ConsoleLog(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  if (options.isPageLogic) {
+    return new naslTypes.CallLogic({
+      calleeNamespace: 'nasl.util',
+      calleeName: 'consoleLog',
+      shortcut: true,
+      arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+        expression: fixExpression(arg, options),
+      })) as naslTypes.Argument[],
+    });
+  }
+  return new naslTypes.CallLogic({
+    calleeNamespace: 'nasl.logging',
+    calleeName: 'INFO',
+    shortcut: true,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2Logging(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  return new naslTypes.CallLogic({
+    calleeNamespace: 'nasl.logging',
+    calleeName: (callee[2] as babelTypes.Identifier).name,
+    shortcut: true,
+    arguments: node.arguments.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2JSONFunctions(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  const curCalleeName = (node.callee as any).property.name;
+  return new naslTypes.CallLogic({
+    calleeNamespace: 'nasl.util',
+    calleeName: curCalleeName,
+    shortcut: true,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+    typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType })),
+  });
+}
+
+function transformCall2CallFunction(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.BinaryExpression | naslTypes.NewList | naslTypes.NewMap | naslTypes.NewComposite | naslTypes.CallFunction {
+  let curCalleeName: string;
+  if (callee.length === 3)
+    curCalleeName = (callee[callee.length - 1] as babelTypes.Identifier).name;
+  else {
+    let _callee = (callee[0] as any).callee;
+    while (_callee.type === 'CallExpression')
+      _callee = _callee.callee;
+    curCalleeName = _callee.property.name;
+  }
+  const argument = callee.length === 3 ? node.arguments : (callee[0] as any).arguments as any;
+
+  if (['plus', 'minus', 'multiply', 'divide', 'remainder', 'STARTWITH', 'ENDWITH', 'LIKE', 'IN'].includes(curCalleeName)) {
+    return transformCallExpressionToBinaryExpression(node, curCalleeName, callee, options);
+  };
+
+  if (['NewList', 'NewMap', 'NewEntity', 'NewStructure', 'NewAnonymousStructure'].includes(curCalleeName)) {
+    return transform2NewExpression(curCalleeName, node, options);
+  }
+
+  // let typeNamespace: string;
+  // if (argument?.[argument.length - 1]?.type === 'ObjectExpression') {
+  // typeNamespace = argument.splice(-1)[0].properties[0].value.value;
+  // }
+  const nodeElement = new naslTypes.CallFunction({
+    calleeNamespace: 'nasl.util',
+    calleeName: curCalleeName,
+    arguments: argument.map((arg: any, index: number) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+      keyword: `str${index + 1}`,
+    })) as naslTypes.Argument[],
+    typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation),
+    // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
+  });
+  return nodeElement;
+}
+
+function transform2UIFunction(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.Destination | naslTypes.CallLogic {
+  if ((callee[2] as babelTypes.Identifier).name === 'destination') {
+    const namespace = (node.arguments[0] as babelTypes.StringLiteral).value;
+    const nsArr = namespace.split('.').map((item) => item.replace(/_view$/, ''));
+    const pageType = nsArr.shift();
+    const viewName = nsArr.pop();
+    const newArguments = node?.arguments?.slice(1);
+    let argument = [] as naslTypes.Argument[];
+    if (newArguments?.[0]?.type === 'ObjectExpression') {
+      argument = newArguments?.[0]?.properties?.map((property: any) => new naslTypes.Argument({
+        keyword: property?.key?.name,
+        expression: fixExpression(property?.value, options),
+      })) as naslTypes.Argument[];
+    } else {
+      argument = node.arguments.slice(1).map((arg) => new naslTypes.Argument({
+        expression: fixExpression(arg, options),
+      })) as naslTypes.Argument[];
+    }
+    return new naslTypes.Destination({
+      viewNamespace: `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((item) => `.${item}.views`)?.join('')}`,
+      viewName,
+      arguments: argument,
+    });
+  }
+  return new naslTypes.CallLogic({
+    calleeNamespace: 'nasl.ui',
+    calleeName: (callee[2] as babelTypes.Identifier).name,
+    shortcut: true,
+    /**
+     * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
+     * @param node
+     * @returns
+     */
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformMap2ListTransform(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallFunction {
+  return new naslTypes.CallFunction({
+    calleeNamespace: 'nasl.util',
+    calleeName: 'ListTransform',
+    arguments: [new naslTypes.Argument({
+      expression: fixExpression((node.callee as babelTypes.MemberExpression).object, options),
+    }), ...node?.arguments?.map((arg: any) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    }))],
+  });
+}
+
+function transform2ForEachStatement(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.ForEachStatement {
+  const newCallee = node.arguments;
+  const arrowFunction = node.arguments[3] as babelTypes.ArrowFunctionExpression;
+  const nodeElement = new naslTypes.ForEachStatement({
+    each: transform2LogicItem(newCallee[0], options),
+    start: transform2LogicItem(newCallee[1], options),
+    end: transform2LogicItem(newCallee[2], options),
+    item: transform2Param(arrowFunction.params[0] as babelTypes.Identifier),
+    index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1] as babelTypes.Identifier) : new naslTypes.Param({
+      name: 'index', typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Long'),
+    }),
+    body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+  });
+  return nodeElement;
+}
+
+function transformForEach2ForEachStatement(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.ForEachStatement {
+  const newCallee = (node.callee as any).object;
+  const arrowFunction = node.arguments[0] as babelTypes.ArrowFunctionExpression;
+  const nodeElement = new naslTypes.ForEachStatement({
+    each: transform2LogicItem(newCallee.callee.object, options),
+    start: transform2LogicItem(newCallee?.arguments?.[0], options),
+    end: transform2LogicItem(newCallee?.arguments?.[1], options),
+    item: transform2Param(arrowFunction.params[0] as babelTypes.Identifier),
+    index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1] as babelTypes.Identifier) : new naslTypes.Param({
+      name: 'index', typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Long'),
+    }),
+    body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+  });
+  return nodeElement;
+}
+
+function transformAlert2ShowMessage(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  return new naslTypes.CallLogic({
+    calleeNamespace: 'nasl.ui',
+    calleeName: 'showMessage',
+    shortcut: true,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2Interface(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallInterface {
+  return new naslTypes.CallInterface({
+    calleeNamespace: generate((node.callee as any).object).code,
+    calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
+    arguments: node?.arguments?.map((arg: any) => arg?.properties?.map((item: any) => new naslTypes.Argument({
+      keyword: item?.key?.name,
+      expression: fixExpression(item?.value, options),
+    })) || []).flat() as naslTypes.Argument[] || [],
+  });
+}
+
+function transformCall2Connector(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallConnector {
+  const flatCalleeKey = generate(node?.callee as any)?.code;
+  const [, calleeConnectionName, calleeNamespace, calleeFunName] = flatCalleeKey?.match(/^(\w+)\.([\w.]+)\.(\w+)$/);
+  return new naslTypes.CallConnector({
+    calleeConnectionName,
+    calleeNamespace,
+    calleeName: calleeFunName,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2Extension(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  return new naslTypes.CallLogic({
+    calleeNamespace: generate((node?.callee as any)?.object)?.code,
+    calleeName: (callee?.[callee?.length - 1] as babelTypes.Identifier)?.name,
+    handleError: true,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformArrowFunction2Match(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.Match | naslTypes.SwitchStatement {
+  // NOTE: 适用于 if else
+  const newCallee = ((node.callee as babelTypes.ArrowFunctionExpression).body as any).body;
+  if (newCallee[newCallee.length - 1].argument?.callee?.name === '__MatchExpressionFuntion') {
+    const match = new naslTypes.Match({
+      expression: fixExpression(newCallee[0], options),
+      isExpression: false,
+      cases: flatIfStatement(newCallee[1].body.body[0]).map((_case: any) => new naslTypes.MatchCase({
+        patterns: !_case.test ? [] : flatMatchPatternsExpression(transform2LogicItem(_case.test, options)) as any,
+        body: _case.consequent.body.filter((item: any) => item.type !== 'BreakStatement').map((item: any) => transform2LogicItem(item, options)).filter((item: any) => !!item),
+      })),
+    });
+    if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
+      match.cases.push(new naslTypes.MatchCase({
+        patterns: [],
+        body: [],
+      }));
+    }
+    match.cases.forEach((case_: any) => {
+      if (case_.body.length && (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
+        case_.isMatchedTypeEnumable = true;
+      }
+      if (case_.patterns.length && case_.patterns[0].concept === 'MemberExpression') {
+        case_.isMatchedTypeEnumable = true;
+        case_.patterns[0] = new naslTypes.MemberExpression({
+          object: {
+            concept: 'Identifier',
+            name: case_.patterns[0].object.property.name,
+            folded: false,
+            namespace: 'app.enums'
+          } as any,
+          property: {
+            concept: 'Identifier',
+            name: case_.patterns[0].property.value,
+            folded: false,
+          } as any,
+        });
+      }
+    });
+    return match;
+  }
+  if (newCallee[newCallee.length - 1].argument?.callee?.name === '__SwitchExpressionFuntion') {
+    const switchStatement = transform2LogicItem(newCallee[0].body.body[0], options) as naslTypes.SwitchStatement;
+    return switchStatement;
+  }
+  throwError(`Unhandled ArrowFunctionExpression node ${node.type}`);
+}
+
+function transformCall2CallViewLogic(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  return new naslTypes.CallLogic({
+    calleeNamespace: '',
+    calleeName: calleeName.slice('viewLogic_'.length),
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2Logic(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  return new naslTypes.CallLogic({
+    calleeNamespace: ``,
+    calleeName,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2LogicWithAuth(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallLogic {
+  return new naslTypes.CallLogic({
+    calleeNamespace: `nasl.auth`,
+    calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
+    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+      expression: fixExpression(arg, options),
+    })) as naslTypes.Argument[],
+  });
+}
+
+function transformCall2Paginate(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.Paginate {
+  const newCallee = node.arguments || [];
+  return new naslTypes.Paginate({
+    list: newCallee[0] && transform2LogicItem(newCallee[0], options),
+    page: newCallee[1] && transform2LogicItem(newCallee[1], options),
+    size: newCallee[2] && transform2LogicItem(newCallee[2], options),
+  });
+}
+
+type CallQueryComponentChainNode = {
+  calleeName: 'FROM' | 'INNER_JOIN' | 'LEFT_JOIN' | 'RIGHT_JOIN' | 'OUTER_JOIN',
+  arguments: [babelTypes.MemberExpression, babelTypes.Identifier, babelTypes.BinaryExpression | babelTypes.LogicalExpression],
+} | {
+  calleeName: 'WHERE' | 'HAVING' | 'GROUP_BY' | 'ORDER_BY' | 'SELECT',
+  arguments: Array<babelTypes.Expression>,
+};
+function flatCallQueryComponentChainNode(node: babelTypes.CallExpression): Array<CallQueryComponentChainNode> {
+  if (node.callee.type === 'Identifier') {
+    const calleeName = node.callee.name;
+    if (['FROM', 'INNER_JOIN', 'LEFT_JOIN', 'RIGHT_JOIN', 'OUTER_JOIN'].includes(calleeName)) {
+      if (node.arguments[1].type !== 'ArrowFunctionExpression')
+        throwError('FROM should have a ArrowFunctionExpression as the second argument');
+
+      const arrowFunctionExpression = node.arguments[1] as babelTypes.ArrowFunctionExpression;
+      if (arrowFunctionExpression.body.type !== 'CallExpression')
+        throwError('FROM should have a CallExpression as the body of ArrowFunctionExpression');
+      const body = arrowFunctionExpression.body as babelTypes.CallExpression;
+      const callExpressions = flatChainCallExpression(body);
+
+      const result: Array<CallQueryComponentChainNode> = [{
+        calleeName: calleeName as 'FROM' | 'INNER_JOIN' | 'LEFT_JOIN' | 'RIGHT_JOIN' | 'OUTER_JOIN',
+        arguments: [node.arguments[0] as babelTypes.MemberExpression, arrowFunctionExpression.params[0] as babelTypes.Identifier, undefined as babelTypes.BinaryExpression | babelTypes.LogicalExpression],
+      }];
+
+      callExpressions.forEach((item) => {
+        if (item.callee.type === 'Identifier')
+          if (item.callee.name === 'ON') {
+            result[0].arguments[2] = item.arguments[0] as babelTypes.BinaryExpression | babelTypes.LogicalExpression;
+          } else if (['INNER_JOIN', 'LEFT_JOIN', 'RIGHT_JOIN', 'OUTER_JOIN'].includes(item.callee.name)) {
+            result.push(...flatCallQueryComponentChainNode(item as babelTypes.CallExpression));
+          } else {
+            result.push({
+              calleeName: item.callee.name as 'WHERE' | 'GROUP_BY' | 'ORDER_BY' | 'SELECT',
+              arguments: item.arguments as Array<babelTypes.Expression>,
+            });
+          }
+      });
+
+      return result;
+    }
+  }
+  return [];
+}
+
+function transformMemberExpression2Entity(node: babelTypes.MemberExpression, node2: babelTypes.Identifier) {
+  const entityPath = flatMemberExpression(node);
+  const entityNamespace = entityPath.slice(0, -1).map(n => (n as babelTypes.Identifier).name).join('.');
+  const entityName = (entityPath[entityPath.length - 1] as babelTypes.Identifier).name.replace(/Entity/, '');
+  const asName = node2.name === entityName ? undefined : node2.name;
+
+  return { entityNamespace, entityName, asName };
+}
+
+function transformCall2DataQuery(node: babelTypes.CallExpression, calleeName: string, callee: babelTypes.Node[], options: TransformOptions): naslTypes.CallQueryComponent {
+  const flatted = flatCallQueryComponentChainNode(node);
+  let from: naslTypes.CallQueryComponent['from'];
+  let where: naslTypes.CallQueryComponent['where'];
+  let having: naslTypes.CallQueryComponent['having'];
+  let groupBy: naslTypes.CallQueryComponent['groupBy'] = [];
+  let orderBy: naslTypes.CallQueryComponent['orderBy'] = [];
+  let select: naslTypes.CallQueryComponent['select'];
+
+  const entityAsNames: Array<string> = [];
+  let entity: ReturnType<typeof transformMemberExpression2Entity>;
+
+  // 这里只是一个示例，具体的逻辑需要根据flatted的内容来构建
+  flatted.forEach((item) => {
+    // console.log(item.calleeName)
+    switch (item.calleeName) {
+      case 'FROM':
+        entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1]);
+        entityAsNames.push(entity.asName || entity.entityName);
+        from = new naslTypes.QueryFromExpression({
+          ...entity,
+          joinParts: [],
+        });
+        break;
+      case 'INNER_JOIN':
+      case 'LEFT_JOIN':
+      case 'RIGHT_JOIN':
+      case 'OUTER_JOIN':
+        entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1]);
+        entityAsNames.push(entity.asName || entity.entityName);
+        const rawJoinType = item.calleeName.slice(0, -5) as 'INNER' | 'LEFT' | 'RIGHT' | 'OUTER';
+        const joinType = rawJoinType === 'OUTER' ? 'FULL' : rawJoinType;
+        from.joinParts.push(new naslTypes.QueryJoinExpression({
+          ...entity,
+          joinType,
+          onExpressions: [transform2BinaryExpression(item.arguments[2], { ...options, entityAsNames })], // toArray
+        }));
+        break;
+      case 'WHERE':
+        where = transform2LogicItem(item.arguments[0], { ...options, entityAsNames });
+        break;
+      case 'HAVING':
+        having = transform2LogicItem(item.arguments[0], { ...options, entityAsNames });
+        break;
+      case 'GROUP_BY':
+        groupBy = item.arguments.map((arg) => new naslTypes.QueryGroupByExpression({
+          groupElement: transform2LogicItem(arg, { ...options, entityAsNames }),
+        }));
+        break;
+      case 'ORDER_BY':
+        orderBy = item.arguments.map((arg: babelTypes.ArrayExpression) => new naslTypes.QueryOrderByExpression({
+          orderElement: transform2LogicItem(arg.elements[0], { ...options, entityAsNames }),
+          order: transform2LogicItem(arg.elements[1], { ...options, entityAsNames })
+        }));
+        break;
+      case 'SELECT':
+        select = new naslTypes.QuerySelectExpression({
+          distinct: false,
+          star: true,
+          selectElements: [],
+        });
+
+        const asNames: Array<string> = [];
+        (item.arguments[0] as babelTypes.ObjectExpression).properties.forEach((arg: babelTypes.ObjectProperty) => {
+          const selectElement = arg.value.type === 'CallExpression' ? transform2QueryAggregateExpression(arg, { ...options, entityAsNames }) : transform2SelectQueryFieldExpression(arg, { ...options, entityAsNames });
+          asNames.push((arg.key as babelTypes.Identifier).name);
+
+          if (selectElement.concept === 'QueryFieldExpression') {
+            const groupByExpression = groupBy.find((groupByExpression) => selectElement.propertyName === (groupByExpression.groupElement as naslTypes.QueryFieldExpression).propertyName);
+            if (groupByExpression) {
+              (groupByExpression.groupElement as naslTypes.QueryFieldExpression).asName = selectElement.asName;
+              return;
+            }
+          }
+          select.selectElements.push(selectElement);
+        });
+
+        orderBy.forEach((orderByExpression) => {
+          const oe = orderByExpression.orderElement as naslTypes.Identifier;
+          if (asNames.includes(oe.name)) {
+            oe.namespace = 'inner';
+          }
+        });
+
+        break;
+    }
+  });
+
+  // 构建并返回 naslTypes.CallQueryComponent 实例
+  const callQueryComponent = new naslTypes.CallQueryComponent({
+    select: select || null,
+    from: from || null,
+    where: where || null,
+    groupBy,
+    having: having || null,
+    orderBy,
+    ideVersion: '2.22',
+  });
+
+  // callQueryComponent.typeAnnotation = callQueryComponent.computeStructure();
+
+  return callQueryComponent;
+}
+
+export function transform2LogicItem(node: babelTypes.Node, options: TransformOptions): naslTypes.LogicItem {
+  fixLogicNode(node);
+
+  const transformManager = new TransformManager();
+
+  transformManager.register('VariableDeclaration', transform2VariableAndAddAssignment);
+  transformManager.register('IfStatement', transform2IfStatement);
+  transformManager.register('WhileStatement', transform2WhileStatement);
+  transformManager.register('SwitchStatement', transformSwitchStatement2Match);
+  transformManager.register('Identifier', transformIdentifier);
+  transformManager.register('ExpressionStatement', (node: babelTypes.ExpressionStatement, options) => transform2LogicItem(node.expression, options));
+  transformManager.register('AssignmentExpression', transform2Assignment);
+  transformManager.register('ArrowFunctionExpression', transform2AnonymousFunction);
+  transformManager.register('BooleanLiteral', transform2BooleanLiteral);
+  transformManager.register('StringLiteral', transform2StringLiteral);
+  transformManager.register('NumericLiteral', transform2NumericLiteral);
+  transformManager.register('NullLiteral', transform2NullLiteral);
+  transformManager.register('TemplateLiteral', transform2StringInterpolation);
+  transformManager.register('BinaryExpression', transform2BinaryExpression);
+  transformManager.register('LogicalExpression', transform2BinaryExpression);
+  transformManager.register('UpdateExpression', transformUpdateExpression2Assignment);
+  transformManager.register('ReturnStatement', transformReturnStatement2AssignmentOrEnd);
+  transformManager.register('EmptyStatement', transform2Comment);
+  transformManager.register('BlockStatement', transformBlockStatement);
+  transformManager.register('ObjectExpression', transform2NewComposite);
+  transformManager.register('NewExpression', transformNewExpression);
+  transformManager.register((node) => node.type === 'UnaryExpression' && ['!'].includes(node.operator), (node: babelTypes.UnaryExpression, options) => {
+    return new naslTypes.UnaryExpression({
+      operator: node.operator as any,
+      argument: transform2LogicItem(node.argument, options),
+    });
+  });
+  transformManager.register((node) => node.type === 'UnaryExpression' && ['-'].includes(node.operator) && node.argument.type === 'NumericLiteral', (node: babelTypes.UnaryExpression, options) => {
+    return transform2NumericLiteral({
+      type: 'NumericLiteral',
+      value: -(node.argument as babelTypes.NumericLiteral).value,
+    }, options);
+  });
+  transformManager.register('MemberExpression', transformMemberExpression);
+  transformManager.register((node) => node.type === 'CallExpression' && node.callee.type === 'CallExpression', transformCallCall2Match);
+  transformManager.registerCallExpression((node, calleeName) => /^\$refs\./.test(calleeName), transformCall2CallViewElementLogic);
+  transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity'), transformCall2CallEntityLogic);
+  transformManager.registerCallExpression('nasl.oql.query', transformCall2OQLQuery);
+  transformManager.registerCallExpression('nasl.util.consoleLog', transformCall2ConsoleLog);
+  transformManager.registerCallExpression('console.log', transformCall2ConsoleLog);
+  transformManager.registerCallExpression((node, calleeName) => calleeName.startsWith('nasl.logging.'), transformCall2Logging);
+  transformManager.registerCallExpression('nasl.util.jsonSerialize', transformCall2JSONFunctions);
+  transformManager.registerCallExpression('nasl.util.jsonDeserialize', transformCall2JSONFunctions);
+  transformManager.registerCallExpression((node, calleeName) => calleeName.startsWith('nasl.util.'), transformCall2CallFunction);
+  transformManager.registerCallExpression((node, calleeName) => calleeName.startsWith('nasl.auth.'), transformCall2LogicWithAuth);
+  transformManager.registerCallExpression((node, calleeName) => calleeName.startsWith('nasl.ui.'), transform2UIFunction);
+  transformManager.registerCallExpression((node, calleeName) => calleeName.endsWith('.map'), transformMap2ListTransform);
+  transformManager.registerCallExpression('ForEach', transform2ForEachStatement);
+  transformManager.registerCallExpression((node, calleeName) => calleeName.endsWith('.forEach'), transformForEach2ForEachStatement);
+  transformManager.registerCallExpression('alert', transformAlert2ShowMessage);
+  transformManager.registerCallExpression((node, calleeName) => /^app.dataSources|app.logics/.test(calleeName), transformCall2CallDataSourceLogic);
+  transformManager.registerCallExpression((node, calleeName) => /interfaces\./.test(calleeName), transformCall2Interface);
+  transformManager.registerCallExpression((node, calleeName) => /connectors\./.test(calleeName), transformCall2Connector);
+  transformManager.registerCallExpression((node, calleeName) => /extensions\./.test(calleeName), transformCall2Extension);
+  transformManager.registerCallExpression((node) => node.callee.type === 'ArrowFunctionExpression', transformArrowFunction2Match);
+  transformManager.registerCallExpression((node, calleeName) => ['plus', 'minus', 'multiply', 'divide', 'remainder', 'STARTWITH', 'ENDWITH', 'LIKE', 'IN'].includes(calleeName), transformCallExpressionToBinaryExpression);
+  transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 1 && calleeName.startsWith('viewLogic_'), transformCall2CallViewLogic);
+
+  transformManager.registerCallExpression('PAGINATE', transformCall2Paginate);
+  transformManager.registerCallExpression('FROM', transformCall2DataQuery);
+
+  transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 1, transformCall2Logic);
+
+  return transformManager.apply(node, options);
+}