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

package/src/natural/transforms/transform2TypeAnnotation.ts

@@ -0,0 +1,77 @@
+import { babelTypes, naslTypes, generate, DEBUG, throwError, tryParseTS } from './utils';
+
+export function transform2TypeAnnotation(node: babelTypes.TSType): naslTypes.TypeAnnotation {
+    if (!node) return null;
+    if (node.type === 'TSTypeReference') {
+      const typeName = (node.typeName as babelTypes.Identifier).name;
+      const primitiveType = naslTypes.primitiveTypeList.find((ta) => ta.typeName === typeName);
+      if ((node as any)?.typeNamespace) {
+        return naslTypes.TypeAnnotation.createReference(typeName, {
+          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;
+      }
+      if (typeName === 'Integer') {
+        return naslTypes.TypeAnnotation.createPrimitive('Long');
+      }
+      if (primitiveType) {
+        return naslTypes.TypeAnnotation.createPrimitive(typeName);
+      }
+      if (['List', 'Map', 'Current'].includes(typeName) && node?.typeParameters) {
+        return naslTypes.TypeAnnotation.createGeneric(typeName, {
+          typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation),
+        });
+      }
+      if (node?.typeName?.type === 'TSQualifiedName' && node?.typeParameters) {
+        const curTypeName = (node?.typeName as any)?.right?.name;
+        return naslTypes.TypeAnnotation.createGeneric(curTypeName, {
+          typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation),
+        });
+      }
+      if (!node.typeParameters) {
+        if (node?.typeName?.type === 'TSQualifiedName') {
+          const allTypeName = generate(node?.typeName?.left as any)?.code;
+          // 实体、枚举、结构体
+          if (/^app.dataSources|.enums|.structures/.test(allTypeName)) {
+            const curTypeName = (node?.typeName as any)?.right?.name;
+            return naslTypes.TypeAnnotation.createReference(curTypeName, {
+              typeNamespace: allTypeName,
+            });
+          }
+        }
+        return naslTypes.TypeAnnotation.createReference(typeName, {
+          typeNamespace: null,
+        });
+      }
+      throwError(`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,
+        typeAnnotation: transform2TypeAnnotation(member.typeAnnotation.typeAnnotation),
+      })));
+    } else if (node.type === 'TSBooleanKeyword') {
+      return naslTypes.TypeAnnotation.createPrimitive('Boolean');
+    } else if (node.type === 'TSStringKeyword') {
+      return naslTypes.TypeAnnotation.createPrimitive('String');
+    } else if (node.type === 'TSNumberKeyword') {
+      return naslTypes.TypeAnnotation.createPrimitive('Double');
+    } else if (node.type === 'TSUnionType') {
+      const union = naslTypes.TypeAnnotation.createPrimitive('Union');
+      union.typeArguments = [];
+      node.types.forEach((curType) => {
+        union.typeArguments.push(transform2TypeAnnotation(curType));
+      });
+      return union;
+    } else {
+      throwError(`Unhandled node ${node.type}`);
+    }
+  }

package/src/natural/transforms/utils.ts

@@ -0,0 +1,25 @@
+import * as babel from '@babel/core';
+import * as babelTypes from '@babel/types';
+import * as naslTypes from '../../concepts';
+import generate from '@babel/generator';
+
+export { babelTypes, naslTypes, generate };
+
+export const DEBUG = false;
+export function throwError(message: string) {
+  if (DEBUG) throw new Error(message);
+  else console.error(message);
+}
+
+export function tryParseTS(tsCode: string) {
+  try {
+    const root = babel.parseSync(tsCode, {
+      filename: 'result.ts',
+      presets: [require('@babel/preset-typescript')],
+    });
+    // console.log((root as any).program.body[0].body.body.map((item) => item.trailingComments));
+    return root;
+  } catch (e) {
+    return null;
+  }
+}

package/src/server/getLogics.ts

@@ -213,19 +213,19 @@ export function getLogicsSync(node: CallLogic | BindEvent | Identifier | Logic,
         path: `${app.getNamespace()}.logics`,
         title: '服务端逻辑',
         logics: javaLogicDataSourceLogics(app.logics).globalLogics,
-        children: [
-          ...nc,
-          ...extensions,
-          ...dependEntityNs,
-          ...ps,
-          new Namespace({
-            name: 'javalogicCategory',
-            title: '扩展逻辑',
-            logics: javaLogicDataSourceLogics(app.logics).javaLogics,
-            expanded: false,
-          }),
-        ],
       });
+      tree.children = [
+        ...nc,
+        ...extensions,
+        ...dependEntityNs,
+        ...ps,
+        new Namespace({
+          name: 'javalogicCategory',
+          title: '扩展逻辑',
+          logics: javaLogicDataSourceLogics(app.logics).javaLogics,
+          expanded: false,
+        }),
+      ];
       tree.expanded = false;
       result.push(tree);
     }

package/src/server/getMemberIdentifier.ts

@@ -15,9 +15,9 @@ import {
   types,
   ViewElement,
   PAGE_COMPONENT_INCLUDE_TAG_MAP,
-  ComponentCompletionPropertyMap,
   configurationEnums,
   processV2Enums,
+  config,
 } from '..';
 import { formatVariableData, formatFrontEndVariables, formatConfigProperties, formatBackendVariables } from './formatTsUtils';
 
@@ -422,8 +422,8 @@ export function getConfigsIdentifier(node: BaseNode): CompletionProperty[] {
 }
 function flatElements(elements: ViewElement[], componentList: CompletionProperty[], nodeParentElement: string, currentAttriBute: string, parentNodeNames: string[]) {
   elements?.forEach((item) => {
-    // 根据ComponentCompletionPropertyMap添加
-    if (ComponentCompletionPropertyMap?.[item.tag]) {
+    // 根据readablePropsMap添加
+    if (config?.allNodesAPI[item.tag] && config?.allNodesAPI[item.tag].readablePropsMap) {
       // 是否当前组件
       const isCurrent = item.name === nodeParentElement;
       const stashItem: any = {
@@ -436,9 +436,9 @@ function flatElements(elements: ViewElement[], componentList: CompletionProperty
         children: [],
       }
 
-      for (const key in ComponentCompletionPropertyMap[item.tag]) {
-        if (Object.prototype.hasOwnProperty.call(ComponentCompletionPropertyMap[item.tag], key)) {
-          const property = ComponentCompletionPropertyMap[item.tag][key];
+      for (const key in config?.allNodesAPI[item.tag].readablePropsMap) {
+        if (Object.prototype.hasOwnProperty.call(config?.allNodesAPI[item.tag].readablePropsMap, key)) {
+          const property = config?.allNodesAPI[item.tag].readablePropsMap[key];
 
           // 如果是当前组件，过滤掉当前属性
           if (!isCurrent || currentAttriBute !== property.prop) {
@@ -454,7 +454,7 @@ function flatElements(elements: ViewElement[], componentList: CompletionProperty
               })
             })
 
-            completionProperty.name = `${key}（${property.label}）`;
+            completionProperty.name = `${key}（${property.title}）`;
             completionProperty.icon = property.icon || 'attr'
             stashItem.children.push(completionProperty)
           }
@@ -511,21 +511,21 @@ function getCurrentElement(item: any): ViewElement | undefined {
   if (!item?.parentNode) return undefined
   if (item.parentNode?.concept === 'ViewElement') {
     return item.parentNode
-  } else if (item.parentNode?.concept === 'View') {
+  } if (item.parentNode?.concept === 'View') {
     return undefined
-  } else {
-    return getCurrentElement(item.parentNode)
   }
+    return getCurrentElement(item.parentNode)
+
 }
 
 function getCurrentAttriBute(item: any): BindAttribute | undefined {
   if (item.concept === 'BindAttribute') {
     return item
-  } else {
+  }
     if (item?.parentNode && item.parentNode?.concept !== 'View') {
       return getCurrentAttriBute(item.parentNode)
-    } else {
-      return undefined
     }
-  }
+      return undefined
+
+
 }

package/src/server/naslServer.ts

@@ -102,6 +102,7 @@ import {
   ProcessBindV2,
   ValidationRule,
   SubLogic,
+  AuthLogicForCallInterface
 } from '../concepts';
 
 import * as utils from '../utils';
@@ -121,7 +122,7 @@ import { EventEmitter } from '../common/EventEmitter';
 import { traverse, FileNode } from '../utils';
 import { withQueueExecute } from '../decorators';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
-import { isConnection, isConnector, isMsgTriggerEvent, isProcess, isProcessV2, isStrictLogic } from '../concepts/utils/asserts';
+import { isApp, isConnection, isConnector, isMsgTriggerEvent, isProcess, isProcessV2, isStrictLogic } from '../concepts/utils/asserts';
 
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
   Entity: 3,
@@ -653,7 +654,7 @@ class NaslServer {
     app.naslServer = this;
     const self = this;
     this.performance = performance;
-    const results = await utils.timeSlicingWithGenerator(getAllTsFiles());
+    const results = await utils.runGeneratorAsync(getAllTsFiles());
     const files = results.map((result) => ({
       file: result.filePath,
       fileContent: result.code,
@@ -3298,7 +3299,13 @@ class NaslServer {
       });
       refsList = [...newRefs.refs];
     } else if (node instanceof Module && !(node instanceof Connector)) {
-      const lists = node.logics || node.structures || node.enums;
+      // 数组有长度的情况下，才去查找
+      const { logics, structures, enums, interfaces } = node;
+      const lists = (logics?.length && logics) ||
+        (structures?.length && structures) ||
+        (enums?.length && enums) ||
+        (interfaces?.length && interfaces);
+      // const lists = node.logics || node.structures || node.enums;
       const moduleName = (fileNode as FileNode).getEmbeddedFilePath();
       if (lists.length) {
         const item = lists[0];
@@ -4900,39 +4907,52 @@ class NaslServer {
 
   // 全量标注并且返回json
   @withQueueExecute('annotation')
-  async getNaslAnnotatedJSON(app: App, releaseFlag: boolean) {
+  async getNaslAnnotatedJSON(naslNode: App | Logic | AuthLogicForCallInterface, releaseFlag: boolean) {
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    const isApp = asserts.isApp(naslNode);
     if (this.changeStackList?.length) {
       throw new Error(`当前还有${this.changeStackList.length}个文件还在执行更新操作`);
     }
-    this.logger.time('全量标注');
+    this.logger.time(`${ isApp ? '全量' : '单文件' }标注`);
     const nodes: QuickInfoNodes = [];
-    this.file2NodeMap.forEach((fileNode, filePath) => {
-      // 先不排除view，传递给后端的时候，去除views下的标注
-      if (!['DataSource','Enum', 'Role'].includes(fileNode.concept)) {
-        fileNode.sourceMap.forEach((item, node) => {
-          nodes.push({
-            filePath,
-            node,
-            item,
-          });
+    if (!isApp) {
+      const filePath = naslNode?.getEmbeddedFilePath();
+      naslNode.sourceMap.forEach((item, node) => {
+        nodes.push({
+          filePath,
+          node,
+          item,
         });
-      }
-    });
+      });
+    } else {
+      this.file2NodeMap.forEach((fileNode, filePath) => {
+        // 先不排除view，传递给后端的时候，去除views下的标注
+        if (!['DataSource','Enum', 'Role'].includes(fileNode.concept)) {
+          fileNode.sourceMap.forEach((item, node) => {
+            nodes.push({
+              filePath,
+              node,
+              item,
+            });
+          });
+        }
+      });
+    }
     const typesMap = await this.getQuickInfoNodesTypeMap(nodes, true);
 
     console.time('app toJSON');
     const jsonMap = new Map();
-    const json = app._toJSON((source, instance) => {
+    const json = naslNode._toJSON((source, instance) => {
       jsonMap.set(instance, source);
       return source;
     });
     console.timeEnd('app toJSON');
 
-    this.logger.timeEnd('全量标注');
+    this.logger.timeEnd(`${ isApp ? '全量' : '单文件' }标注`);
 
     // 测试环境或者是调试模式打印数据
     if (utils.isDebugMode || utils.isTestBrowser) {
-      this.logger.info('全量标注数据', json);
+      this.logger.info(`${ isApp ? '全量' : '单文件' }标注数据`, json);
     }
 
     if (releaseFlag) {

package/src/server/translator.ts

@@ -332,6 +332,11 @@ const TS_RULES: Array<{
     re: /Cannot find name '__UNSUPPORTED__ENTITY__FIELDS__'./,
     result: '可能为实体属性别名，动态条件中仅支持使用变量',
   },
+  {
+    re: /Cannot find name '__UNDEFINED__VARIABLE__(.+?)__'./,
+    result: '所选择的内容 $1 未定义。',
+    transforms: [outOriginalvalue],
+  },
   {
     re: /No value exists in scope for the shorthand property '__(?:IDENTIFIER|LEFT|RIGHT)__'. Either declare one or provide an initializer./,
     result: '用户任务未关联页面',

package/src/templator/block2nasl/jsx2nasl/index.ts

@@ -0,0 +1,11 @@
+import transformExpression2nasl from './transform-expression2nasl';
+import transformTsType2Nasl from './transform-tstype2nasl';
+import transformFunc2Nasl from './transform-func2nasl';
+import transformTSX2Nasl from './transform-tsx2nasl';
+
+export {
+  transformExpression2nasl,
+  transformTsType2Nasl,
+  transformFunc2Nasl,
+  transformTSX2Nasl,
+};

package/src/templator/block2nasl/jsx2nasl/transform-expression2nasl.ts

@@ -0,0 +1,238 @@
+/* eslint-disable no-use-before-define */
+// @ts-nocheck
+import {
+  ArrowFunctionExpression,
+  CallExpression,
+  Expression,
+  ObjectExpression,
+} from '@babel/types';
+import generate from '@babel/generator';
+import { getNodeCode } from './utils';
+import { transformParam2Nasl } from './transform-func2nasl';
+import transformTypeAnnotation from './transform-tstype2nasl';
+
+const getNamespace = (ast) => {
+  if (ast.object && ast.object.name === 'nasl' && ast.property && ast.property.name) {
+    return `nasl.${ast.property.name}`;
+  }
+
+  return '';
+};
+
+function transformObjectExpression2Nasl(ast: ObjectExpression) {
+  const newMap: any = {
+    concept: 'NewMap',
+    keys: [],
+    values: [],
+  };
+
+  ast.properties.forEach((property) => {
+    if (property.type === 'ObjectMethod' || property.type === 'SpreadElement' || property.key.type === 'PrivateName') {
+      throw new Error(`解析Expression失败，nasl未支持该表达式, ${getNodeCode(ast)}`);
+    }
+
+    newMap.keys.push(transformExpression2Nasl(property.key));
+    newMap.values.push(transformExpression2Nasl(property.value as any));
+  });
+  return newMap;
+}
+
+function getCallName(code: string) {
+  let namespace = '';
+  let name = '';
+
+  const arr = code.split('.');
+
+  if (code.startsWith('$refs.')) {
+    arr[0] = 'elements';
+    arr.splice(arr.length - 1, 0, 'logics');
+  }
+
+  namespace = arr.slice(0, arr.length - 1).join('.');
+  name = arr[arr.length - 1];
+
+  const Entity = 'Entity';
+  if (namespace.endsWith(Entity)) {
+    namespace = `${namespace.substring(0, namespace.lastIndexOf(Entity))}.logics`;
+  }
+
+  return { namespace, name };
+}
+
+function transformCallExpress2Nasl(ast: CallExpression) {
+  if (ast.callee.type === 'Super' || ast.callee.type === 'V8IntrinsicIdentifier') {
+    throw new Error(`解析CallExpression 失败，${getNodeCode(ast)}`);
+  }
+
+  const code = getNodeCode(ast.callee);
+  const { namespace, name } = getCallName(code);
+
+  const args = ast.arguments.map((arg) => {
+    if (arg.type === 'JSXNamespacedName' || arg.type === 'SpreadElement' || arg.type === 'ArgumentPlaceholder') {
+      throw new Error(`解析CallExpression 失败，不支持参数类型，${getNodeCode(ast)}`);
+    }
+
+    return {
+      concept: 'Argument',
+      keyword: '',
+      expression: transformExpression2Nasl(arg),
+    };
+  });
+
+  const SHORTCUT_NAMES = ['consoleLog', 'jsonSerialize', 'jsonDeserialize'];
+  if (namespace === 'nasl.util') {
+    return {
+      concept: 'CallFunction',
+      calleeNamespace: namespace,
+      calleeName: name,
+      shortcut: SHORTCUT_NAMES.indexOf(name) !== -1,
+      arguments: args,
+      typeArguments: ast.typeParameters ? ast.typeParameters.params.map((tsType) => transformTypeAnnotation(tsType)) : [],
+    }
+  }
+
+  return {
+    concept: 'CallLogic',
+    arguments: args,
+    calleeNamespace: namespace,
+    calleeName: name,
+    shortcut: namespace === 'nasl.ui',
+  };
+}
+
+function transformArrowFunctionExpression(ast: ArrowFunctionExpression) {
+  if (ast.body.type === 'BlockStatement') {
+    throw new Error(`解析Expression失败，箭头函数仅支持表达式, ${getNodeCode(ast)}`);
+  }
+
+  return {
+    concept: 'AnonymousFunction',
+    params: ast.params.map((p) => transformParam2Nasl(p)),
+    body: transformExpression2Nasl(ast.body),
+  };
+}
+
+export function transformExpression2Nasl(ast: Expression, namespace = '') {
+  switch (ast.type) {
+    case 'MemberExpression':
+      // eslint-disable-next-line no-case-declarations
+      const ns = getNamespace(ast.object);
+      if (ast.property.type === 'PrivateName') {
+        throw new Error(`Expression 解析失败，不支持 PrivateName, ${getNodeCode(ast)}`);
+      }
+      // object如果返回字符串，则将它当成namespace处理
+      if (ns) {
+        return transformExpression2Nasl(ast.property, ns);
+      }
+      return {
+        concept: 'MemberExpression',
+        name: '',
+        kind: 'Expression',
+        object: transformExpression2Nasl(ast.object),
+        property: transformExpression2Nasl(ast.property),
+      };
+    case 'Identifier':
+      return {
+        concept: 'Identifier',
+        namespace,
+        name: ast.name,
+        kind: 'Expression',
+      };
+    case 'TemplateLiteral':
+      return {
+        concept: 'StringInterpolation',
+        kind: 'Expression',
+        name: '',
+        expressions: [...(ast.quasis || []), ...(ast.expressions || [])]
+          .sort((node1: any, node2: any) => {
+            return node1.start - node2.start;
+          })
+          .map((n: any) => {
+            return transformExpression2Nasl(n);
+          }),
+      };
+    case 'StringLiteral':
+      return {
+        concept: 'StringLiteral',
+        kind: 'Expression',
+        name: '',
+        value: ast.value,
+      };
+    case 'NumericLiteral':
+      return {
+        concept: 'NumericLiteral',
+        value: String(ast.value),
+        typeAnnotation: {
+          concept: 'TypeAnnotation',
+          typeKind: 'primitive',
+          typeName: String(ast.value).includes('.') ? 'Decimal' : 'Long',
+          typeNamespace: 'nasl.core',
+          inferred: false,
+          ruleMap: new Map(),
+        },
+      };
+    case 'NullLiteral':
+      return {
+        concept: 'NullLiteral',
+      };
+    case 'BooleanLiteral':
+      return {
+        concept: 'BooleanLiteral',
+        value: String(ast.value),
+      };
+    case 'UnaryExpression':
+      if (ast.argument.type === 'NumericLiteral') {
+        return {
+          concept: 'NumericLiteral',
+          value: ast.operator + ast.argument.value,
+        };
+      }
+
+      return {
+        concept: 'UnaryExpression',
+        kind: 'Expression',
+        name: '',
+        operator: ast.operator,
+        argument: transformExpression2Nasl(ast.argument),
+      };
+    case 'LogicalExpression':
+    case 'BinaryExpression':
+      if (ast.left.type === 'PrivateName') {
+        throw new Error(`Expression 解析失败，不支持 PrivateName, ${getNodeCode(ast)}`);
+      }
+
+      return {
+        concept: 'BinaryExpression',
+        operator: ast.operator,
+        left: transformExpression2Nasl(ast.left),
+        right: transformExpression2Nasl(ast.right),
+      };
+    case 'ArrayExpression':
+      return {
+        concept: 'NewList',
+        items: ast.elements.map((e) => {
+          if (!e || e.type === 'SpreadElement') {
+            throw new Error('解析Expression失败，数组中不允许出现 null, 或者 ...');
+          }
+
+          return transformExpression2Nasl(e);
+        }),
+      };
+    case 'ObjectExpression':
+      return transformObjectExpression2Nasl(ast);
+    case 'AssignmentExpression':
+      return {
+        concept: 'Assignment',
+        left: transformExpression2Nasl(ast.left as any),
+        right: transformExpression2Nasl(ast.right),
+      };
+    case 'ArrowFunctionExpression':
+      return transformArrowFunctionExpression(ast);
+    case 'CallExpression':
+      return transformCallExpress2Nasl(ast);
+    default:
+      throw new Error(`解析Expression失败，nasl未支持该表达式, ${getNodeCode(ast)}`);
+  }
+}
+
+export default transformExpression2Nasl;