@lcap/nasl 3.3.0-alpha.1 → 3.3.0-alpha.3

package/src/natural/transformTSCode.ts

@@ -1,32 +1,9 @@
-import * as naslTypes from '../concepts';
-
-// 走 babel 走 ts 都行，可能 babel 跟我们语法树更像一些
-// import * as ts from 'typescript';
-// export function transformFromTS2(tsCode: string, contextLogicName: string) {
-//     const result: Array<naslTypes.BaseNode> = [];
-
-//     const sourceFile = ts.createSourceFile(`result.ts`, tsCode, ts.ScriptTarget.ESNext);
-//     let realBody: ts.Node;
-//     function findRealBody(node: ts.Node) {
-//         if (ts.isFunctionDeclaration(node) && node.name.escapedText === contextLogicName) {
-//             return realBody = node.body;
-//         } else {
-//             node.forEachChild(findRealBody);
-//         }
-//     }
-//     sourceFile.forEachChild(findRealBody);
-
-//     if (!realBody)
-//         throw new Error('无法找到实现的函数！');
-
-//     realBody.forEachChild((node) => {
-//         console.log(node);
-//     });
-// }
-
+/* eslint-disable global-require */
+/* eslint-disable @typescript-eslint/no-use-before-define */
 import * as babel from '@babel/core';
 import * as babelTypes from '@babel/types';
 import generate from '@babel/generator';
+import * as naslTypes from '../concepts';
 import { traverse } from '../utils';
 
 export function tryParseTS(tsCode: string) {
@@ -42,6 +19,31 @@ export function tryParseTS(tsCode: string) {
     }
 }
 
+function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
+  if (node.type === 'MemberExpression')
+      return [...flatMemberExpression(node.object), node.property];
+  return [node];
+}
+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
@@ -72,18 +74,19 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
             }
             if (primitiveType) {
                 return naslTypes.TypeAnnotation.createPrimitive(typeName);
-            } else if (['List', 'Map', 'Current'].includes(typeName) && node.typeParameters) {
+            }
+            if (['List', 'Map', 'Current'].includes(typeName) && node.typeParameters) {
                 return naslTypes.TypeAnnotation.createGeneric(typeName, {
                     typeArguments: node.typeParameters.params.map(transformTypeAnnotation),
                 });
-            } else if (!node.typeParameters) {
+            }
+            if (!node.typeParameters) {
                 return naslTypes.TypeAnnotation.createReference(typeName, {
                     typeNamespace: 'app.dataSources.defaultDS',
                 });
-            } else {
-                console.error(node);
-                throw new Error('Unhandled node ' + node.type);
             }
+            console.error(node);
+            throw new Error(`Unhandled node ${node.type}`);
         } else if (node.type === 'TSTypeLiteral') {
             return naslTypes.TypeAnnotation.createTypeAnonymousStructure(node.members.map((member: babelTypes.TSPropertySignature) => new naslTypes.StructureProperty({
                 name: (member.key as babelTypes.Identifier).name,
@@ -98,13 +101,13 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         } else if (node.type === 'TSUnionType') {
             const union = naslTypes.TypeAnnotation.createPrimitive('Union');
             union.typeArguments = [];
-            node.types.forEach((type) => {
-                union.typeArguments.push(transformTypeAnnotation(type));
+            node.types.forEach((curType) => {
+                union.typeArguments.push(transformTypeAnnotation(curType));
             });
             return union;
         } else {
             console.error(node);
-            throw new Error('Unhandled node ' + node.type);
+            throw new Error(`Unhandled node ${node.type}`);
         }
     }
     function transformParam(node: babelTypes.Identifier): naslTypes.Param {
@@ -115,45 +118,49 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         });
     }
     function pushElseIf(ifNode: babelTypes.IfStatement, switchStatement: naslTypes.SwitchStatement) {
-        switchStatement.cases.push(new naslTypes.SwitchCase({
-            test: transformLogicNode(ifNode.test),
-            consequent: !ifNode.consequent ? [] : (ifNode.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-        }));
-        if (ifNode.alternate && ifNode.alternate.type === 'IfStatement') {
-            pushElseIf(ifNode.alternate, switchStatement);
-        } else {
-            switchStatement.cases.push(new naslTypes.SwitchCase({
-                test: undefined,
-                consequent: !ifNode.consequent ? [] : (ifNode.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-            }));
-        }
-    }
+      switchStatement.cases.push(new naslTypes.SwitchCase({
+          test: transformLogicNode(ifNode.test),
+          consequent: !ifNode.consequent ? [] : (ifNode.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+      }));
+      if (ifNode.alternate && ifNode.alternate.type === 'IfStatement') {
+          pushElseIf(ifNode.alternate, switchStatement);
+      } else {
+          switchStatement.cases.push(new naslTypes.SwitchCase({
+              test: undefined,
+              consequent: !ifNode.consequent ? [] : (ifNode.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+          }));
+      }
+  }
+
     function transformLogicNode(node: babelTypes.Node, typeAnnotation?: naslTypes.TypeAnnotation): naslTypes.LogicItem {
         fixLogicNode(node);
         // console.log('lemon ~~~ node--1:', node);
         if (node.type === 'VariableDeclaration') { // 拆成局部变量和赋值
-            const decl = node.declarations[0];
-            const variableName = (decl.id as babelTypes.Identifier).name;
-            if (!logic.variables.find((variable) => variable.name === variableName)) {
-                const typeAnnotation = ((decl.id as babelTypes.Identifier).typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
+            const declList = node?.declarations || [];
+            declList?.forEach((decl) => {
+              const variableName = (decl.id as babelTypes.Identifier).name;
+              if (!logic.variables.find((variable) => variable.name === variableName)) {
+                const varTypeAnnotation = ((decl.id as babelTypes.Identifier).typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
                 logic.variables.push(new naslTypes.Variable({
-                    name: variableName,
-                    typeAnnotation: typeAnnotation && transformTypeAnnotation(typeAnnotation),
+                  name: variableName,
+                  typeAnnotation: varTypeAnnotation && transformTypeAnnotation(varTypeAnnotation),
                 }));
-            }
-            if (decl.init) {
+              }
+              if (decl.init) {
                 if (decl.init.type !== 'ArrayExpression') {
-                    if (type === 'expression') {
-                        return transformLogicNode(decl.init);
-                    }
-                    return new naslTypes.Assignment({
-                        left: new naslTypes.Identifier({
-                            name: variableName,
-                        }),
-                        right: transformLogicNode(decl.init),
-                    });
+                  if (type === 'expression') {
+                    return transformLogicNode(decl.init);
+                  }
+                  const item = new naslTypes.Assignment({
+                    left: new naslTypes.Identifier({
+                      name: variableName,
+                    }),
+                    right: transformLogicNode(decl.init),
+                  });
+                  item && logic.body.push(item);
                 }
-            }
+              }
+            });
         } else if (node.type === 'CallExpression') {
             const callee = flatMemberExpression(node.callee);
             const calleeName = generate(node.callee as any).code;
@@ -166,7 +173,8 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
                         expression: transformLogicNode(arg),
                     })) as naslTypes.Argument[],
                 });
-            } else if (callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity')) {
+            }
+            if (callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity')) {
                 const entityName = callee[0].name.replace(/Entity$/, '');
                 return new naslTypes.CallLogic({
                     calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
@@ -175,13 +183,15 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
                         expression: transformLogicNode(arg),
                     })) as naslTypes.Argument[],
                 });
-            } else if (calleeName === 'nasl.oql.query') {
+            }
+            if (calleeName === 'nasl.oql.query') {
                 return new naslTypes.OqlQueryComponent({
                     dataSource: 'app.dataSources.defaultDS',
                     code: generate(node.arguments[0] as any).code.trim().slice(1, -1),
                 });
-            } else if (calleeName.startsWith('nasl.util.')) {
-                const calleeName = callee.length === 3 ? (callee[callee.length - 1] as babelTypes.Identifier).name : (callee[0] as any).callee.property.name;
+            }
+            if (calleeName.startsWith('nasl.util.')) {
+                const curCalleeName = callee.length === 3 ? (callee[callee.length - 1] as babelTypes.Identifier).name : (callee[0] as any).callee.property.name;
                 const argument = callee.length === 3 ? node.arguments : (callee[0] as any).arguments as any;
                 let typeNamespace: string;
                 if (argument?.[argument.length - 1]?.type === 'ObjectExpression') {
@@ -189,17 +199,18 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
                 }
                 const nodeElement = new naslTypes.CallFunction({
                     calleeNamespace: 'nasl.util',
-                    calleeName,
+                    calleeName: curCalleeName,
                     arguments: argument.map((arg: any, index: number) => new naslTypes.Argument({
                         expression: transformLogicNode(arg),
                         keyword: `str${index + 1}`,
                     })) as naslTypes.Argument[],
-                    typeArguments: node?.typeParameters?.params.map((type: any) => transformTypeAnnotation({ ...type, typeNamespace })),
+                    typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType, typeNamespace })),
 
                 });
                 // console.log('lemon ~ callFunction ~ 3:', nodeElement);
                 return nodeElement;
-            } else if (callee.length === 3 && calleeName.startsWith('nasl.ui.')) {
+            }
+            if (callee.length === 3 && calleeName.startsWith('nasl.ui.')) {
                 return new naslTypes.CallLogic({
                     calleeNamespace: 'nasl.ui',
                     calleeName: (callee[2] as babelTypes.Identifier).name,
@@ -213,15 +224,29 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
                         expression: transformLogicNode(arg),
                     })) as naslTypes.Argument[],
                 });
-            } else if (callee.length === 2) {
-                const calleeName = (node.callee as any).property.name;
-                if (calleeName === 'forEach') {
-                    const newCallee = callee[0] as any;
+            }
+            if (calleeName === 'ForEach') {
+                const newCallee = node.arguments;
+                const arrowFunction = node.arguments[3] as babelTypes.ArrowFunctionExpression;
+                const nodeElement = new naslTypes.ForEachStatement({
+                  each: transformLogicNode(newCallee[0]),
+                  start: transformLogicNode(newCallee[1]),
+                  end: transformLogicNode(newCallee[2]),
+                  item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
+                  index: transformParam(arrowFunction.params[1] as babelTypes.Identifier),
+                  body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+                });
+                return nodeElement;
+            }
+            if (callee.length === 2) {
+                const curCalleeName = (node.callee as any).property.name;
+                if (curCalleeName === 'forEach') {
+                    const newCallee = (node.callee as any).object;
                     const arrowFunction = node.arguments[0] as babelTypes.ArrowFunctionExpression;
                     const nodeElement = new naslTypes.ForEachStatement({
                         each: transformLogicNode(newCallee.callee.object),
-                        start: transformLogicNode(newCallee.arguments[0]),
-                        end: transformLogicNode(newCallee.arguments[1]),
+                        start: transformLogicNode(newCallee?.arguments?.[0]),
+                        end: transformLogicNode(newCallee?.arguments?.[1]),
                         item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
                         index: transformParam(arrowFunction.params[1] as babelTypes.Identifier),
                         body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
@@ -332,23 +357,16 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
                         }
                     });
                     return match;
-                } else if (newCallee[newCallee.length - 1].argument?.callee?.name === '__SwitchExpressionFuntion') {
+                }
+                if (newCallee[newCallee.length - 1].argument?.callee?.name === '__SwitchExpressionFuntion') {
                     const switchStatement = transformLogicNode(newCallee[0].body.body[0]);
-                    // const switchStatement = new naslTypes.SwitchStatement({
-                    //     cases: newCallee[0].body.body.map((_case: any) => new naslTypes.SwitchCase({
-                    //         test: transformLogicNode(_case.test),
-                    //         consequent: !_case.consequent ? [] : (_case.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-                    //     })),
-                    // });
-                    // switchStatement.cases.push(new naslTypes.SwitchCase({}));
                     return switchStatement;
-                } else {
-                    console.error(node);
-                    throw new Error('Unhandled ArrowFunctionExpression node ' + node.type);
                 }
+                console.error(node);
+                throw new Error(`Unhandled ArrowFunctionExpression node ${node.type}`);
             } else {
                 console.error(node);
-                throw new Error('Unhandled node ' + callee.map((item: babelTypes.Identifier) => item.name).join('.') + ' ' + node.type);
+                throw new Error(`Unhandled node ${callee.map((item: babelTypes.Identifier) => item.name).join('.')} ${node.type}`);
             }
         } else if (node.type === 'IfStatement') {
             if (node.alternate && node.alternate.type === 'IfStatement') {
@@ -357,13 +375,12 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
                 });
                 pushElseIf(node, switchStatement);
                 return switchStatement;
-            } else {
-                return new naslTypes.IfStatement({
-                    test: transformLogicNode(node.test),
-                    consequent: !node.consequent ? [] : (node.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-                    alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-                });
             }
+            return new naslTypes.IfStatement({
+                test: transformLogicNode(node.test),
+                consequent: !node.consequent ? [] : (node.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+                alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+            });
         } else if (node.type === 'WhileStatement') {
             return new naslTypes.WhileStatement({
                 test: transformLogicNode(node.test),
@@ -408,12 +425,11 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
                         }),
                     ],
                 });
-            } else {
-                return new naslTypes.MemberExpression({
-                    object: transformLogicNode(node.object),
-                    property: transformLogicNode(node.property),
-                });
             }
+            return new naslTypes.MemberExpression({
+                object: transformLogicNode(node.object),
+                property: transformLogicNode(node.property),
+            });
         } else if (node.type === 'Identifier') {
             return new naslTypes.Identifier({
                 name: node.name,
@@ -437,23 +453,21 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
                         right: transformLogicNode(node.right),
                     }),
                 });
-            } else {
-                if (type === 'expression') {
-                    return transformLogicNode(node.right);
-                }
-                return new naslTypes.Assignment({
-                    left: transformLogicNode(node.left),
-                    right: transformLogicNode(node.right),
-                });
             }
+            if (type === 'expression') {
+                return transformLogicNode(node.right);
+            }
+            return new naslTypes.Assignment({
+                left: transformLogicNode(node.left),
+                right: transformLogicNode(node.right),
+            });
         } else if (node.type === 'NewExpression') {
             const calleeName = generate(node.callee as any).code;
             if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {
                 return transformLogicNode(node.arguments[0], naslTypes.TypeAnnotation.createPrimitive(calleeName));
-            } else {
-                console.error(node);
-                throw new Error('Unhandled node ' + node.type);
             }
+            console.error(node);
+            throw new Error(`Unhandled node ${node.type}`);
         } else if (node.type === 'ArrowFunctionExpression') {
             return new naslTypes.AnonymousFunction({
                 params: node.params.map((param: babelTypes.Identifier) => transformParam(param)),
@@ -499,25 +513,24 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
                     left: transformLogicNode(node.left),
                     right: transformLogicNode(node.right),
                 });
-            } else {
-                console.error(node);
-                throw new Error('Unhandled node ' + node.type);
             }
+            console.error(node);
+            throw new Error(`Unhandled node ${node.type}`);
         } else if (node.type === 'UnaryExpression') {
             if (['!'].includes(node.operator)) {
                 return new naslTypes.UnaryExpression({
                     operator: node.operator as any,
                     argument: transformLogicNode(node.argument),
                 });
-            } else if (['-'].includes(node.operator) && node.argument.type === 'NumericLiteral') {
+            }
+            if (['-'].includes(node.operator) && node.argument.type === 'NumericLiteral') {
                 return transformLogicNode({
                     type: 'NumericLiteral',
                     value: -node.argument.value,
                 } as babelTypes.NumericLiteral);
-            } else {
-                console.error(node);
-                throw new Error('Unhandled node ' + node.type);
             }
+            console.error(node);
+            throw new Error(`Unhandled node ${node.type}`);
         } else if (node.type === 'UpdateExpression') {
             if (node.operator === '++' || node.operator === '--') {
                 return new naslTypes.Assignment({
@@ -553,9 +566,11 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
             return node.leadingComments && new naslTypes.Comment({
                 value: String(node.leadingComments[0].value),
             });
+        } else if (node.type === 'BlockStatement') {
+            return transformLogicNode(node?.body?.[0]);
         } else {
-            console.error(node);
-            throw new Error('Unhandled node ' + node.type);
+          console.error(node);
+          throw new Error(`Unhandled node ${node.type}`);
         }
     }
 
@@ -612,33 +627,6 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
     return logic;
 }
 
-function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
-    if (node.type === 'MemberExpression')
-        return [...flatMemberExpression(node.object), node.property];
-    else
-        return [node];
-}
-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];
-    } else
-        return [node];
-}
-
-function flatIfStatement(node: any): Array<babelTypes.Node> {
-    if (node.alternate.type === 'IfStatement') {
-        return [...flatIfStatement(node.alternate), node];
-    } else {
-        return [node];
-    }
-}
-
 export function tryTransformTSCode(tsCode: string, contextLogicName: string, type?: string): naslTypes.Logic {
     if (tsCode.includes('```')) {
         const cap = tsCode.match(/```.*\n([\s\S]+?)```/);
@@ -653,9 +641,9 @@ export function transformTSCodeEx(answer: any, activeLogic: any, context: any) {
     let logicName = activeLogic.name;
     const { app, nasl } = context;
     if (activeLogic.parentNode instanceof nasl.BindEvent && activeLogic.parentNode.parentNode instanceof nasl.View) {
-        logicName = 'on_view_' + activeLogic.name;
+        logicName = `on_view_${activeLogic.name}`;
     } else if (activeLogic.parentNode instanceof nasl.BindEvent && activeLogic.parentNode.parentNode instanceof nasl.ViewElement) {
-        logicName = 'on_' + (activeLogic.parentNode).element.name + '_' + activeLogic.name;
+        logicName = `on_${(activeLogic.parentNode).element.name}_${activeLogic.name}`;
     } else {
         logicName = activeLogic.name;
     }
@@ -686,7 +674,7 @@ export function transformTSCodeToExpression(answer: any, context: any) {
     }
     const { app } = context;
     app.emit('collect:start', { actionMsg: '自然语言生成代码' });
-    const body = logic.body;
+    const { body } = logic;
     app.emit('collect:end');
     return body;
 }