@lcap/nasl 3.7.0-alpha.1 → 3.7.0-beta.1

package/src/concepts/Logic__.ts

@@ -1,4 +1,3 @@
-import { v4 as uuidv4 } from 'uuid';
 import {
   wrapForEachToGenerator as wrapForEach,
   wrapIteratorToGenerator as wrapIterator,
@@ -19,6 +18,7 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
+import type App from './App__';
 import type Namespace from './Namespace__';
 import type CallQueryComponent from './CallQueryComponent__';
 import type ForEachStatement from './ForEachStatement__';
@@ -35,31 +35,33 @@ import type CallLogic from './CallLogic__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 import type Interface from './Interface__';
 import type BusinessComponent from './BusinessComponent__';
+import type AnonymousFunction from './AnonymousFunction__';
 
+import type Module from './Module__';
+import type Connector from './Connector__';
+import type View from './View__';
+import type Frontend from './Frontend__';
+import type ProcessElement from './ProcessElement__';
+import type Process from './Process__';
+import type CallFunction from './CallFunction__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } 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 BaseNode from '../common/BaseNode';
-import type Transactional from './Transactional__';
-import type TypeParam from './TypeParam__';
-import type Param from './Param__';
-import type Return from './Return__';
-import type Variable from './Variable__';
-import type LogicItem from './LogicItem__';
-import type Module from './Module__';
-import type Connector from './Connector__';
-import type View from './View__';
-import type ProcessElement from './ProcessElement__';
-import type App from './App__';
-import type Frontend from './Frontend__';
-import type Process from './Process__';
+import Transactional from './Transactional__';
+import TypeParam from './TypeParam__';
+import Param from './Param__';
+import Return from './Return__';
+import Variable from './Variable__';
+import LogicItem from './LogicItem__';
 
 /**
  * 逻辑
@@ -68,7 +70,11 @@ import type Process from './Process__';
 export class Logic extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Logic';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['BaseNode'];
 
@@ -78,42 +84,53 @@ export class Logic extends BaseNode {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'Logic' | 'AuthLogic' | 'AuthLogicForCallInterface' | 'BusinessLogic';
-
   /**
    * 逻辑名称
    */
-  @property()
-  name!: string;
+  @property({
+    objectRef: '',
+  })
+  name: string = '';
 
   /**
    * 逻辑标题
    */
-  @property()
-  title!: string;
+  @property({
+    objectRef: '',
+  })
+  title: string;
 
   /**
    * 逻辑描述
    */
-  @property()
-  description!: string;
+  @property({
+    objectRef: '',
+  })
+  description: string;
 
   /**
    * 触发方式
    */
-  @property()
-  triggerType!: string;
+  @property({
+    objectRef: '',
+  })
+  triggerType: string;
 
   /**
    * 定时任务表达式
    */
-  @property()
-  cron!: string;
+  @property({
+    objectRef: '',
+  })
+  cron: string;
 
   /**
    * 是否可覆写
    */
-  @property()
-  overridable!: boolean;
+  @property({
+    objectRef: '',
+  })
+  overridable: boolean;
 
   /**
    * 事务
@@ -121,7 +138,7 @@ export class Logic extends BaseNode {
   @property({
     objectRef: 'Transactional',
   })
-  transactional!: Transactional;
+  transactional: Transactional;
 
   /**
    * 类型参数列表
@@ -131,7 +148,7 @@ export class Logic extends BaseNode {
     isArray: true,
     defaultValue: null,
   })
-  typeParams: Array<TypeParam> = null;
+  typeParams?: Array<TypeParam> = null;
 
   /**
    * 输入参数列表
@@ -183,60 +200,11 @@ export class Logic extends BaseNode {
   })
   playground: Array<LogicItem> = [];
 
-  /**
-   * 祖先 Module
-   */
-  get module() {
-    return this.getAncestor('Module') as Module;
-  }
-
-  /**
-   * 祖先 App
-   */
-  get app() {
-    return this.getAncestor('App') as App;
-  }
-
-  /**
-   * 祖先 Connector
-   */
-  get connector() {
-    return this.getAncestor('Connector') as Connector;
-  }
-
-  /**
-   * 祖先 View
-   */
-  get view() {
-    return this.getAncestor('View') as View;
-  }
-
-  /**
-   * 祖先 Frontend
-   */
-  get frontend() {
-    return this.getAncestor('Frontend') as Frontend;
-  }
-
-  /**
-   * 祖先 ProcessElement
-   */
-  get processElement() {
-    return this.getAncestor('ProcessElement') as ProcessElement;
-  }
-
-  /**
-   * 祖先 Process
-   */
-  get process() {
-    return this.getAncestor('Process') as Process;
-  }
-
   /**
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<Logic>) {
-    source = { ...Logic.getDefaultOptions(), ...source};
+    source = Object.assign({}, Logic.getDefaultOptions(), source);
     super(source);
     super.subConstructor(source);
   }
@@ -245,18 +213,6 @@ export class Logic extends BaseNode {
     return super.from(source, parentNode, parentKey) as Logic;
   }
 
-  /**
-   * 从父级删除该节点
-   * @internal
-   */
-  _delete() {
-    let params: Params = null;
-    if (this.parentNode) {
-      params = (this.parentNode as any)?.__removeLogic?.(this);
-    }
-    return params;
-  }
-
   /**
    * 设置逻辑名称
    */
@@ -347,9 +303,8 @@ export class Logic extends BaseNode {
 
   getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.typeParams as TypeParam[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.typeParams as TypeParam[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-
   getTypeParamUniqueName(name = 'typeParam1') {
     return utils.unique(name, this.getTypeParamExistingNames(), undefined, false);
   }
@@ -1152,62 +1107,6 @@ export class Logic extends BaseNode {
     return node;
   }
 
-  /**
-   * 删除事务
-   * @param name 事务名称
-   */
-  removeTransactional(name: string): void;
-
-  /**
-   * 删除事务
-   * @param transactional 已有的事务实例
-   */
-  removeTransactional(transactional: Transactional): void;
-
-  removeTransactional(options: string | Transactional) {
-    let transactional: Transactional;
-    if (typeof options === 'string') {
-      transactional = this.transactional;
-      if (!transactional) {
-        throw new Error(`找不到事务 ${  options}`);
-      }
-    } else {
-      transactional = options;
-    }
-    return transactional.delete();
-  }
-
-  __removeTransactional(transactional: Transactional) {
-    const {parentKey} = transactional;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: transactional,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = transactional.__v_raw || transactional;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除类型参数
    * @param name 类型参数名称
@@ -1225,7 +1124,7 @@ export class Logic extends BaseNode {
     if (typeof options === 'string') {
       typeParam = (this.typeParams as TypeParam[]).find((item) => item.name === options);
       if (!typeParam) {
-        throw new Error(`找不到类型参数 ${  options}`);
+        throw new Error('找不到类型参数 ' + options);
       }
     } else {
       typeParam = options;
@@ -1233,37 +1132,6 @@ export class Logic extends BaseNode {
     return typeParam.delete();
   }
 
-  __removeTypeParam(typeParam: TypeParam) {
-    const {parentKey} = typeParam;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: typeParam,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = typeParam.__v_raw || typeParam;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除输入参数
    * @param name 输入参数名称
@@ -1281,7 +1149,7 @@ export class Logic extends BaseNode {
     if (typeof options === 'string') {
       param = (this.params as Param[]).find((item) => item.name === options);
       if (!param) {
-        throw new Error(`找不到输入参数 ${  options}`);
+        throw new Error('找不到输入参数 ' + options);
       }
     } else {
       param = options;
@@ -1289,37 +1157,6 @@ export class Logic extends BaseNode {
     return param.delete();
   }
 
-  __removeParam(param: Param) {
-    const {parentKey} = param;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: param,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = param.__v_raw || param;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除输出参数
    * @param name 输出参数名称
@@ -1337,7 +1174,7 @@ export class Logic extends BaseNode {
     if (typeof options === 'string') {
       ret = (this.returns as Return[]).find((item) => item.name === options);
       if (!ret) {
-        throw new Error(`找不到输出参数 ${  options}`);
+        throw new Error('找不到输出参数 ' + options);
       }
     } else {
       ret = options;
@@ -1345,37 +1182,6 @@ export class Logic extends BaseNode {
     return ret.delete();
   }
 
-  __removeReturn(ret: Return) {
-    const {parentKey} = ret;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: ret,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = ret.__v_raw || ret;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除变量
    * @param name 变量名称
@@ -1393,7 +1199,7 @@ export class Logic extends BaseNode {
     if (typeof options === 'string') {
       variable = (this.variables as Variable[]).find((item) => item.name === options);
       if (!variable) {
-        throw new Error(`找不到变量 ${  options}`);
+        throw new Error('找不到变量 ' + options);
       }
     } else {
       variable = options;
@@ -1401,37 +1207,6 @@ export class Logic extends BaseNode {
     return variable.delete();
   }
 
-  __removeVariable(variable: Variable) {
-    const {parentKey} = variable;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: variable,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = variable.__v_raw || variable;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除逻辑项
    * @param logicItem 已有的逻辑项实例
@@ -1439,7 +1214,7 @@ export class Logic extends BaseNode {
   removeItemInBody(logicItem: LogicItem): void;
 
   removeItemInBody(options: LogicItem) {
-    const logicItem: LogicItem = options;
+    let logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
@@ -1450,45 +1225,51 @@ export class Logic extends BaseNode {
   removeItemInPlayground(logicItem: LogicItem): void;
 
   removeItemInPlayground(options: LogicItem) {
-    const logicItem: LogicItem = options;
+    let logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
-  __removeLogicItem(logicItem: LogicItem) {
-    const {parentKey} = logicItem;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logicItem,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logicItem.__v_raw || logicItem;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
+  /**
+   * 祖先 Module
+   */
+  get module() {
+    return this.getAncestor('Module') as Module;
+  }
+  /**
+   * 祖先 Connector
+   */
+  get connector() {
+    return this.getAncestor('Connector') as Connector;
+  }
+  /**
+   * 祖先 View
+   */
+  get view() {
+    return this.getAncestor('View') as View;
+  }
+  /**
+   * 祖先 Frontend
+   */
+  get frontend() {
+    return this.getAncestor('Frontend') as Frontend;
+  }
+  /**
+   * 祖先 ProcessElement
+   */
+  get processElement() {
+    return this.getAncestor('ProcessElement') as ProcessElement;
+  }
+  /**
+   * 祖先 Process
+   */
+  get process() {
+    return this.getAncestor('Process') as Process;
+  }
+
   // 用于calllogic树中定位是那个logic，回显
   get calleewholeKey() {
     return `${this.getNamespace()}.${this.name}`;
@@ -1656,105 +1437,100 @@ export class Logic extends BaseNode {
     };
   }
 
-
-
-
   toMockService() {
-  // 本此考虑将return 的类型 生成到 returnType: {}  字段
-  // 在运行时根据类型直接生成mock数据
-     const mockService:any  = this.toService()
-     mockService.returns =   this.returns?.map(re=>{
+    // 本此考虑将return 的类型 生成到 returnType: {}  字段
+    // 在运行时根据类型直接生成mock数据
+    const mockService: any = this.toService();
+    mockService.returns = this.returns?.map((re) => {
       // if(!re?.typeAnnotation){debugger}
-      let tA = re?.typeAnnotation  || re?.__TypeAnnotation
+      let tA = re?.typeAnnotation || re?.__TypeAnnotation;
       return {
-        typeAnnotation : tA?.toJS()
-      }
-    })
-    return mockService
+        typeAnnotation: tA?.toJS(),
+      };
+    });
+    return mockService;
   }
 
-
   toService() {
-      const { parentNode } = this;
-      const { concept, name: entityName } = parentNode || {};
-      const logicName = this.name;
-      let serviceType = 'micro';
-      let method = 'POST';
-      let path = `/api/lcplogics/${logicName}`;
-      if (concept === 'Module') {
-        path = `/api/${entityName.replace('-', '_')}/${logicName}`;
-      } else if (concept === 'Namespace') {
-        serviceType = 'entity';
-        let entityPath = entityName.replace(/[A-Z]/g, (char, index) => {
-          const lowerChar = char.toLowerCase();
-          return index === 0 ? lowerChar : `-${lowerChar}`;
-        });
-        const dataSource = parentNode.getAncestor('DataSource');
-        // 默认数据源不动，其他数据源需要拼接数据源信息
-        if (dataSource && dataSource.name !== 'defaultDS') {
-          entityPath = `${dataSource.name}/${entityPath}`;
-        }
-        path = `/api/${entityPath}`;
-        switch (this.name) {
-          case 'get':
-            method = 'GET';
-            path = `/api/${entityPath}`;
-            break;
-          case 'create':
-            method = 'POST';
-            break;
-          case 'update':
-            method = 'PUT';
-            break;
-          case 'delete':
-            method = 'DELETE';
-            path = `/api/${entityPath}`;
-            break;
-          case 'createOrUpdate':
-            method = 'POST';
-            path = `/api/${entityPath}/createOrUpdate`;
-            break;
-          case 'updateBy':
-            method = 'PUT';
-            path = `/api/${entityPath}/by`;
-            break;
-          case 'deleteBy':
-            method = 'DELETE';
-            path = `/api/${entityPath}/by`;
-            break;
-          case 'batchCreate':
-            method = 'POST';
-            path = `/api/${entityPath}/batch`;
-            break;
-          case 'batchUpdate':
-            method = 'PUT';
-            path = `/api/${entityPath}/batch`;
-            break;
-          case 'batchDelete':
-            method = 'DELETE';
-            path = `/api/${entityPath}/batch`;
-            break;
-          case 'import':
-            method = 'POST';
-            path = `/api/${entityPath}/import`;
-            break;
-          default:
-            break;
-        }
+    const { parentNode } = this;
+    const { concept, name: entityName } = parentNode || {};
+    const logicName = this.name;
+    let serviceType = 'micro';
+    let method = 'POST';
+    let path = `/api/lcplogics/${logicName}`;
+    if (concept === 'Module') {
+      path = `/api/${entityName.replace('-', '_')}/${logicName}`;
+    } else if (concept === 'Namespace') {
+      serviceType = 'entity';
+      let entityPath = entityName.replace(/[A-Z]/g, (char, index) => {
+        const lowerChar = char.toLowerCase();
+        return index === 0 ? lowerChar : `-${lowerChar}`;
+      });
+      const dataSource = parentNode.getAncestor('DataSource');
+      // 默认数据源不动，其他数据源需要拼接数据源信息
+      if (dataSource && dataSource.name !== 'defaultDS') {
+        entityPath = `${dataSource.name}/${entityPath}`;
       }
+      path = `/api/${entityPath}`;
+      switch (this.name) {
+        case 'get':
+          method = 'GET';
+          path = `/api/${entityPath}`;
+          break;
+        case 'create':
+          method = 'POST';
+          break;
+        case 'update':
+          method = 'PUT';
+          break;
+        case 'delete':
+          method = 'DELETE';
+          path = `/api/${entityPath}`;
+          break;
+        case 'createOrUpdate':
+          method = 'POST';
+          path = `/api/${entityPath}/createOrUpdate`;
+          break;
+        case 'updateBy':
+          method = 'PUT';
+          path = `/api/${entityPath}/by`;
+          break;
+        case 'deleteBy':
+          method = 'DELETE';
+          path = `/api/${entityPath}/by`;
+          break;
+        case 'batchCreate':
+          method = 'POST';
+          path = `/api/${entityPath}/batch`;
+          break;
+        case 'batchUpdate':
+          method = 'PUT';
+          path = `/api/${entityPath}/batch`;
+          break;
+        case 'batchDelete':
+          method = 'DELETE';
+          path = `/api/${entityPath}/batch`;
+          break;
+        case 'import':
+          method = 'POST';
+          path = `/api/${entityPath}/import`;
+          break;
+        default:
+          break;
+      }
+    }
 
-      return {
-        config: {
-          serviceType,
-        },
-        url: {
-          method,
-          path,
-        },
-      };
+    return {
+      config: {
+        serviceType,
+      },
+      url: {
+        method,
+        path,
+      },
+    };
   }
 
-
   @withSourceMapGenerator
   *toEmbeddedTSInProcess(
     state = createCompilerState(),
@@ -1815,9 +1591,9 @@ export class Logic extends BaseNode {
     return code;
   }
 
-  toEmbeddedTSNoExport(state?: TranslatorState): void {
+  toEmbeddedTSNoExport(state?: TranslatorState): string {
+    return runSync(this.toEmbeddedTS(state, 'noExport'));
   }
-
   get tsName() {
     // 来自集成中心，且是连接内部的逻辑，则认为是编辑态的，需要加上后缀
     if (this.connector && this.integration) {
@@ -1865,28 +1641,42 @@ export class Logic extends BaseNode {
       code += '()';
     }
     // 需要类型推导的局部变量/返回值需要调整申明顺序
-    const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
+    const advanceMap: Map<Return | Variable, Assignment | BatchAssignment | CallFunction> = 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 (el && (
+        // 批量赋值
+        asserts.isBatchAssignment(el)
+        // 赋值
+        || (asserts.isAssignment(el) && el.left?.name)
+        // 内置函数对集合类型的推导
+        || (
+          asserts.isCallFunction(el) && el.derivablecollection?.name
+        )
+      )) {
+        if (asserts.isAssignment(el) || asserts.isCallFunction(el)) {
+          let expression: LogicItem;
+          if (asserts.isAssignment(el)) {
+            // 需要被推导的赋值左侧
+            expression = el.left;
+          } else if (asserts.isCallFunction(el)) {
+            // 需要被推导的集合
+            expression = el.derivablecollection;
+          }
+          // 宽泛意义上的变量（变量+出参）
+          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
+            return !variable.typeAnnotation && expression?.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('');
+                returnOrigin('');
             const advanceVar = self.variables?.find(
               (variable) => !variable.typeAnnotation && leftCode === variable.name,
             );
@@ -1908,10 +1698,6 @@ export class Logic extends BaseNode {
         returnOrigin('');
     }
     code += '{\n';
-    if (self.exportInterface) {
-      code += indent((state?.tabSize || 0) + 1);
-      code += `let exportInterface = app.interfaces.${self.exportInterface.name};\n`
-    }
     // 用于虚拟节点的查找引用
     if (Array.isArray(self.virtualParams)) {
       for (const param of self.virtualParams) {
@@ -1953,6 +1739,26 @@ export class Logic extends BaseNode {
         return;
       }
       code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
+      if (asserts.isCallFunction(assignment)) {
+        yield* wrapForEach([
+          {
+            key: 'key',
+            node: assignment.keyOfCollection
+          },
+          {
+            key: 'item',
+            node: assignment.itemOfCollection
+          }
+        ], function* warpForEachGenerator({ key, node: itemNode }) {
+          if (itemNode) {
+            code += `const __${key}_${node?.name} = `;
+            const itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
+            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            code += ';\n';
+          }
+        });
+      }
       code += `${indent((state?.tabSize || 0) + 1)}let `;
       code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
       if (asserts.isBatchAssignment(assignment)) {
@@ -1961,7 +1767,7 @@ export class Logic extends BaseNode {
             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('');
+              returnOrigin('');
           if (leftCode === node.name) {
             const rightNode: any =
               rightIndex.length === 1
@@ -1989,28 +1795,37 @@ export class Logic extends BaseNode {
           }
         });
       } else if (
-        ['NewList', 'NewMap'].includes(assignment.right?.concept) &&
-        !(assignment.right as any)?.typeAnnotation
+        ['NewList', 'NewMap'].includes((assignment as Assignment).right?.concept) &&
+        !((assignment as Assignment).right as any)?.typeAnnotation
       ) {
-        const rightNode: any = assignment.right;
+        const rightNode: any = (assignment as 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'
+        (assignment as Assignment).right?.concept === 'NewComposite' &&
+        ((assignment as Assignment).right as any)?.typeAnnotation?.typeKind === 'anonymousStructure'
       ) {
-        const rightNode: any = assignment.right;
+        const rightNode: any = (assignment as 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'
+        (assignment as Assignment).right?.concept === 'NewComposite' &&
+        ((assignment as Assignment).right as any)?.typeAnnotation?.typeKind === 'generic'
       ) {
-        const rightNode: any = assignment.right;
+        const rightNode: any = (assignment as Assignment).right;
         code += ' = ';
         code += yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }));
+      } else if (asserts.isCallFunction((assignment as CallFunction))) {
+        const nodeName = node?.name;
+        const keyNode = (assignment as CallFunction).keyOfCollection;
+        const itemNode = (assignment as CallFunction).itemOfCollection;
+        if ((assignment as CallFunction).isDerivableMap && keyNode && itemNode) {
+          code += `: nasl.collection.Map<typeof __key_${nodeName}, typeof __item_${nodeName}>`;
+        } else if ((assignment as CallFunction).isDerivableList && itemNode) {
+          code += `: nasl.collection.List<typeof __item_${nodeName}>;`;
+        }
       } else {
-        const rightNode: any = assignment.right;
+        const rightNode: any = (assignment as Assignment).right;
         // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
         if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
           code += ': ';
@@ -2113,6 +1928,8 @@ ${indent(state.tabSize)} */\n`;
         logicName = `viewLogic_${name}`;
       } else if (parentNode?.concept === 'BindEvent') {
         logicName = `on_${parentNode?.parentNode?.name}_${name}`;
+      } else if (this?.concept === 'BusinessLogic') {
+        logicName = `businessLogic_${name}`;
       } else {
         logicName = this.name;
       }
@@ -2210,9 +2027,15 @@ ${indent(state.tabSize)} */\n`;
     return code;
   }
 
-  *getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any) {
+  *getRightCode(code: string, assignment: Assignment | BatchAssignment | CallFunction, rightNode: any) {
     code = code.replaceAll('\n', ' ');
-    if (asserts.isAssignment(assignment) && !assignment.right) return code;
+    // 赋值语句的右侧或者集合内置函数的参数
+    if (
+      (asserts.isAssignment(assignment) && !assignment.right)
+      || (asserts.isCallFunction(assignment) && ((assignment.isDerivableList && !assignment.itemOfCollection) || (assignment.isDerivableMap && !(assignment.keyOfCollection && assignment.itemOfCollection))))
+    ) {
+      return code;
+    }
 
     // 调用接口，参数替换成 null
     if (asserts.isCallInterface(rightNode)) {
@@ -2234,6 +2057,12 @@ ${indent(state.tabSize)} */\n`;
     if (forEachStatement) {
       code = yield* this.handleForEachCode(code, forEachStatement);
     }
+    // 可迭代的集合
+    const callFunction = assignment.getAncestor('CallFunction') as CallFunction;
+    if (callFunction && callFunction.isLoopCollection) {
+      const anonymousFunction = assignment.getAncestor('AnonymousFunction') as AnonymousFunction;
+      code = yield* this.handleCollectionCode(code, anonymousFunction, callFunction);
+    }
     // Match 需要针对分支缩小类型范围
     const matchCase = assignment.getAncestor('MatchCase') as MatchCase;
     if (matchCase) {
@@ -2282,6 +2111,31 @@ ${indent(state.tabSize)} */\n`;
     return code;
   }
 
+  *handleCollectionCode(code: string, anonymousFunction: AnonymousFunction, callFunction: CallFunction): Generator<any, string, any> {
+    const { collection } = callFunction;
+    const self = this;
+    yield* wrapForEach(anonymousFunction.params, function* warpForEachGenerator(param, index) {
+      if (code.includes(param?.name)) {
+        const collectionTSCode = collection ? yield* collection.toEmbeddedTS() : '__IDENTIFIER__';
+        code = self.handleReplaceCode(
+          code,
+          param.name,
+          collectionTSCode === '__IDENTIFIER__' ? collectionTSCode : callFunction.isLoopMap && index === 0 ? `${collectionTSCode}.__getKey(0)` : `${collectionTSCode}.__get(0)`,
+        );
+      }
+    });
+    const parentForEachStatement = callFunction.getAncestor('ForEachStatement') as ForEachStatement;
+    if (parentForEachStatement) {
+      code = yield* this.handleForEachCode(code, parentForEachStatement);
+    }
+    const parentCallFunction = callFunction.getAncestor('CallFunction') as CallFunction;
+    if (parentCallFunction?.isLoopCollection) {
+      const parentAnonymousFunction = callFunction.getAncestor('AnonymousFunction') as AnonymousFunction;
+      code = yield* this.handleCollectionCode(code, parentAnonymousFunction, parentCallFunction);
+    }
+    return code;
+  }
+
   *handleMatchCaseCode(code: string, matchCase: MatchCase): Generator<any, string, any> {
     const match = matchCase.getAncestor('Match') as Match;
     const expressionTsCode = yield* match.expression.toEmbeddedTS();
@@ -2407,9 +2261,8 @@ ${indent(state.tabSize)} */\n`;
     if (asserts.isFrontendLibrary(this.parentNode)) {
       _path += `/frontends/${this.parentNode.type}`;
     } else if (this.parentNode.concept === 'BindEvent' && this.getAncestor('Frontend')) {
-      _path += `/frontendTypes/${this.getAncestor('FrontendType')?.name}/frontends/${
-        this.getAncestor('Frontend')?.name
-      }/bindEvents/${name}.ts`;
+      _path += `/frontendTypes/${this.getAncestor('FrontendType')?.name}/frontends/${this.getAncestor('Frontend')?.name
+        }/bindEvents/${name}.ts`;
     }
     return `/embedded/${this.getAncestor('App')?.name}${_path}/logics/${name}.ts`;
   }