@lcap/nasl 3.5.0-beta.1 → 3.5.0-beta.2

package/src/concepts/BusinessLogic__.ts

@@ -0,0 +1,376 @@
+import {
+  wrapForEachToGenerator as wrapForEach,
+  wrapIteratorToGenerator as wrapIterator,
+  returnOrigin,
+} from '../utils/time-slicing';
+import { waitOqlQueryComponentChildrenFinish } from '../common';
+import {
+  shiftState,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  TranslatorGenerator,
+} from '../translator';
+import { Variable } from './Variable__';
+import { Return } from './Return__';
+import { Assignment } from './Assignment__';
+import { BatchAssignment } from './BatchAssignment__';
+import { Param } from './Param__';
+import { BusinessComponent } from './BusinessComponent__';
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+
+import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
+import { v4 as uuidv4 } from 'uuid';
+import Logic from './Logic__';
+
+/**
+ * 业务组件逻辑
+ */
+@concept('业务组件逻辑')
+export class BusinessLogic extends Logic {
+  /** 类名 */
+  static readonly ConceptName: string = 'BusinessLogic';
+
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['Logic', 'BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'BusinessLogic';
+
+  /**
+   * 是否开放外部调用
+   */
+  @property()
+  isPublic!: boolean;
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<BusinessLogic>) {
+    source = Object.assign({}, BusinessLogic.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): BusinessLogic {
+    return super.from(source, parentNode, parentKey) as BusinessLogic;
+  }
+
+  /**
+   * 设置是否开放外部调用
+   */
+  setIsPublic(isPublic: boolean) {
+    const object = {
+      isPublic,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+  static getDefaultOptions(): Partial<{
+    body: Array<any>;
+    params: Array<any>;
+    returns: Array<any>;
+    description: string;
+  }>  {
+    return {
+      description: '内部实现逻辑',
+    };
+  }
+
+  get businessComponent() {
+    return this.getAncestor('BusinessComponent') as BusinessComponent;
+  }
+
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), prefix?: string, hideDefaultValue?: boolean): TranslatorGenerator {
+    const self = this;
+    // 等待 oql 查询返回内容
+    yield waitOqlQueryComponentChildrenFinish(self);
+    // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
+    let code = '';
+    // 用来储存默认值翻译结构是__IDENTIFIER__或者__IDENTIFIER__()的节点
+    const IDENTIFIERMAP = new Set<Variable | Return>();
+    if (this.businessComponent) {
+      if (!self.isPublic) {
+        code += 'private ';
+      }
+      code += self.name;
+    }
+    if (self.typeParams?.length) {
+      code += '<';
+      yield* wrapForEach(self.typeParams, function* warpForEachGenerator(typeParam, typeParamIndex) {
+        code += yield* typeParam.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        if (typeParamIndex !== self.typeParams.length - 1) code += ', ';
+      });
+      code += '>';
+    }
+    // 有参数长度
+    if (self.params.length) {
+      code += '(';
+      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
+        code += yield* param.toEmbeddedTS(shiftState(state, code));
+        if (index !== self.params.length - 1) code += ', ';
+      });
+      code += ')';
+    } else {
+      // 没有参数的
+      code += '()';
+    }
+    // 需要类型推导的局部变量/返回值需要调整申明顺序
+    const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
+    // const needGetSourceMapOqlList: Promise<any>[] = [];
+    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
+      if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
+        if (asserts.isAssignment(el)) {
+          const advanceVar = self.variables?.find(
+            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
+          );
+          if (advanceVar && !advanceMap.get(advanceVar)) {
+            advanceMap.set(advanceVar, el);
+          }
+          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
+          if (advanceRn && !advanceMap.get(advanceRn)) {
+            advanceMap.set(advanceRn, el);
+          }
+        } else if (asserts.isBatchAssignment(el)) {
+          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
+            const leftCode =
+              leftIndex.length === 1
+                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
+                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
+            const advanceVar = self.variables?.find(
+              (variable) => !variable.typeAnnotation && leftCode === variable.name,
+            );
+            if (advanceVar && !advanceMap.get(advanceVar)) {
+              advanceMap.set(advanceVar, el);
+            }
+            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
+            if (advanceRn && !advanceMap.get(advanceRn)) {
+              advanceMap.set(advanceRn, el);
+            }
+          });
+        }
+      }
+    });
+    // 兼容 return 没有类型情况
+    if (self.returns.length && self.returns[0].typeAnnotation) {
+      code += ': ';
+      code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+        returnOrigin('');
+    }
+    code += '{\n';
+    // 用于虚拟节点的查找引用
+    if (Array.isArray(self.virtualParams)) {
+      for (const param of self.virtualParams) {
+        code += indent((state?.tabSize || 0) + 1);
+        code += yield* param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
+        code += '\n';
+      }
+    }
+
+    for (const variable of self.variables) {
+      const ts = yield* variable.defaultValue?.toEmbeddedTS?.() ?? utils.returnOrigin('');
+      if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
+        IDENTIFIERMAP.add(variable);
+      }
+      if (!advanceMap.get(variable)) {
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
+        code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += ';\n';
+      }
+    }
+
+    for (const ret of self.returns) {
+      const ts = yield* ret.defaultValue?.toEmbeddedTS?.() ?? returnOrigin('');
+      if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
+        IDENTIFIERMAP.add(ret);
+      }
+      if (!advanceMap.get(ret)) {
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
+        code += yield* ret.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += ';\n';
+      }
+    }
+
+    yield* wrapIterator(advanceMap.entries(), function* warpForEachGenerator([node, assignment]) {
+      // 有默认值的用默认值来推导类型, 但是如果是__IDENTIFIER__或者__IDENTIFIER__()，就不需要默认值来推导了
+      if (node.defaultValue?.expression && !IDENTIFIERMAP.has(node)) {
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
+        code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        return;
+      }
+      code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
+      code += `${indent((state?.tabSize || 0) + 1)}let `;
+      code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      if (asserts.isBatchAssignment(assignment)) {
+        yield* wrapForEach(assignment.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
+          const leftCode =
+            leftIndex.length === 1
+              ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
+              : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
+          if (leftCode === node.name) {
+            const rightNode: any =
+              rightIndex.length === 1
+                ? assignment.rights[rightIndex[0]]?.expression
+                : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
+            // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
+            if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
+              if (rightNode.concept === 'NewComposite' && rightNode.typeAnnotation?.typeKind === 'anonymousStructure') {
+                code += '= ';
+                code += (yield* rightNode.getInitCode(shiftState(state, code, { inline: true }))) || 'null';
+              } else if (rightNode.concept === 'NewComposite' && rightNode.typeAnnotation?.typeKind === 'generic') {
+                code += '= ';
+                code += (yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }))) || 'null';
+              } else {
+                code += ': ';
+                code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                  returnOrigin('null');
+              }
+            } else {
+              code += ' = ';
+              const rightCode = yield* rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
+              code += yield* self.getRightCode(rightCode, assignment, rightNode);
+            }
+          }
+        });
+      } else if (
+        ['NewList', 'NewMap'].includes(assignment.right?.concept) &&
+        !(assignment.right as any)?.typeAnnotation
+      ) {
+        const rightNode: any = assignment.right;
+        code += ' = ';
+        code += yield* rightNode.getInitCode(shiftState(state, code, { inline: true }));
+      } else if (
+        assignment.right?.concept === 'NewComposite' &&
+        (assignment.right as any)?.typeAnnotation?.typeKind === 'anonymousStructure'
+      ) {
+        const rightNode: any = assignment.right;
+        code += ' = ';
+        code += yield* rightNode.getInitCode(shiftState(state, code, { inline: true }));
+      } else if (
+        assignment.right?.concept === 'NewComposite' &&
+        (assignment.right as any)?.typeAnnotation?.typeKind === 'generic'
+      ) {
+        const rightNode: any = assignment.right;
+        code += ' = ';
+        code += yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }));
+      } else {
+        const rightNode: any = assignment.right;
+        // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
+        if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
+          code += ': ';
+          code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+            returnOrigin('null');
+        } else {
+          code += ' = ';
+          let rightCode = '';
+          // 因为右侧枚举要赋值就得new 一下；
+          if (
+            rightNode &&
+            asserts.isIdentifier(rightNode) &&
+            rightNode.namespace &&
+            rightNode.namespace.endsWith('enums')
+          ) {
+            rightCode += 'new ';
+          }
+          rightCode +=
+            rightNode && rightNode.toEmbeddedTS
+              ? yield* rightNode.toEmbeddedTS(shiftState(state, code, { inline: true }))
+              : '__RIGHT__';
+          code += yield* self.getRightCode(rightCode, assignment, rightNode);
+        }
+      }
+      code += ';\n';
+    });
+
+    // 参数的默认值是__IDENTIFIER__或者__IDENTIFIER__()时不赋默认值，但是需要ts翻译出来进行报错校验
+    if (!hideDefaultValue) {
+      for (const node of IDENTIFIERMAP.values()) {
+        code += yield* node.defaultValue.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += '; ';
+      }
+      code += '\n';
+    }
+
+    if (!this.body.length && this.returns.length) {
+      code += `${indent((state?.tabSize || 0) + 1)}return ${this.returns[0].name};\n`;
+    } else {
+      // 如果长度小于2 并且不是虚拟节点就 加 报错，
+      if (self.body.length <= 2 && !asserts.isNamespace(self.parentNode)) {
+        if (self.body.length && self.body[0].concept === 'JavaLogic') {
+          code += '';
+        } else {
+          code += indent((state?.tabSize || 0) + 1);
+          code += 'const __LogicEmpty: any = null;';
+        }
+      }
+      yield* wrapForEach(self.body, function* warpForEachGenerator(item) {
+        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ??
+          returnOrigin('');
+        code += ';\n';
+      });
+    }
+    // 在body渲染完成之后把其余的节点放到下面
+    yield* wrapForEach(self.playground, function* warpForEachGenerator(item) {
+      code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+      code += ';\n';
+    });
+
+    if (!hideDefaultValue) {
+      function* setPlaygroundCode(arr: Variable[] | Param[] | Return[], name: string) {
+        if (arr.length) {
+          code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是 ${name} 的默认值草稿------ */\n`;
+        }
+
+        for (const item1 of arr) {
+          for (const item of item1.defaultValue?.playground ?? []) {
+            code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+            code += ';\n';
+          }
+        }
+      }
+
+      yield* setPlaygroundCode(self.variables, 'variables');
+      yield* setPlaygroundCode(self.returns, 'returns');
+      yield* setPlaygroundCode(self.params, 'params');
+    }
+
+    code += `${indent(state?.tabSize || 0)}}`;
+    if (prefix === 'inObject') {
+      code += `,`;
+    }
+    code += '\n';
+    return code;
+  }
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default BusinessLogic;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/CallAuthInterface__.ts

@@ -22,8 +22,8 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
-import * as Type from './utils/types';
-import * as Assert from './utils/asserts';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import CallInterface from './CallInterface__';
 import type Argument from './Argument__';
@@ -33,13 +33,12 @@ import type LogicItem from './LogicItem__';
  * 调用接口
  */
 @concept('调用接口')
-// @ts-ignore
 export class CallAuthInterface extends CallInterface {
   /** 类名 */
-  static readonly ConceptName = 'CallAuthInterface';
+  static readonly ConceptName: string = 'CallAuthInterface';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['CallInterface', 'LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['CallInterface', 'LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -125,7 +124,7 @@ export class CallAuthInterface extends CallInterface {
         this,
         'authArguments',
       );
-    } else if (Assert.isArgument(options)) {
+    } else if (asserts.isArgument(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       argument = options;
       Object.assign(argument, relationOptions);
@@ -311,7 +310,7 @@ export class CallAuthInterface extends CallInterface {
     const relationOptions = { parentNode: this, parentKey: 'arguments' };
     const Argument = getConceptConstructor('Argument');
     let argument: Argument;
-    if (Assert.isArgument(options)) {
+    if (asserts.isArgument(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       argument = options;
       Object.assign(argument, relationOptions);

package/src/concepts/CallConnector__.ts

@@ -25,8 +25,8 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
-import * as Type from './utils/types';
-import * as Assert from './utils/asserts';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import CallLogic from './CallLogic__';
 
@@ -34,13 +34,12 @@ import CallLogic from './CallLogic__';
  * 调用连接器
  */
 @concept('调用连接器')
-// @ts-ignore
 export class CallConnector extends CallLogic {
   /** 类名 */
-  static readonly ConceptName = 'CallConnector';
+  static readonly ConceptName: string = 'CallConnector';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['CallLogic', 'LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['CallLogic', 'LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -53,7 +52,6 @@ export class CallConnector extends CallLogic {
    * calleeConnectionName
    */
   @property()
-  // @ts-ignore
   calleeConnectionName!: string;
 
   /**