@lcap/nasl 3.3.0-beta.0 → 3.4.0-alpha.1

package/src/concepts/Logic__.ts

@@ -1,12 +1,6 @@
+import { v4 as uuidv4 } from 'uuid';
 import { FrontendLibrary } from './FrontendLibrary__';
-import {
-  TranslatorState,
-  shiftState,
-  withSourceMap,
-  indent,
-  createCompilerState,
-  embeddedTSEmitter,
-} from '../translator';
+import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
 import Namespace from './Namespace__';
 import CallQueryComponent from './CallQueryComponent__';
 import ForEachStatement from './ForEachStatement__';
@@ -20,18 +14,19 @@ import MatchCase from './MatchCase__';
 import TypeAnnotation from './TypeAnnotation__';
 import CallInterface from './CallInterface__';
 import CallLogic from './CallLogic__';
+import ViewElement from './ViewElement__';
 import { SynatxNode } from './types__';
 
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
-import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
 import Transactional from './Transactional__';
 import TypeParam from './TypeParam__';
 import Param from './Param__';
@@ -45,72 +40,59 @@ import ProcessElement from './ProcessElement__';
 import App from './App__';
 import Frontend from './Frontend__';
 import Process from './Process__';
-import { NaslServer } from 'src/server';
 
 /**
  * 逻辑
  */
-@className
 @concept('逻辑')
-// @ts-ignore
 export class Logic extends BaseNode {
-  /** 类名 */
-  static readonly ConceptName = 'Logic';
-
   /**
    * 产品概念
    */
-  // @ts-ignore
-  readonly concept!: 'Logic' | 'AuthLogic' | 'AuthLogicForCallInterface';
-
-  /**
-   * 逻辑名称
-   */
   @property()
-  // @ts-ignore
-  name!: string;
+  concept: 'Logic' | 'AuthLogic' | 'AuthLogicForCallInterface' = 'Logic';
 
   /**
-   * 逻辑标题
+   * 逻辑名称
    */
   @property()
-  // @ts-ignore
-  title!: string;
+  name: string = undefined;
 
   /**
    * 逻辑描述
    */
   @property()
-  // @ts-ignore
-  description!: string;
+  description: string = undefined;
 
   /**
-   * 触发方式
+   * triggerType
    */
   @property()
-  // @ts-ignore
-  triggerType!: string;
+  triggerType: string = undefined;
 
   /**
-   * 定时任务表达式
+   * cron
    */
   @property()
-  // @ts-ignore
-  cron!: string;
+  cron: string = undefined;
 
   /**
-   * 是否可覆写
+   * overridable
    */
   @property()
-  // @ts-ignore
-  overridable!: boolean;
+  overridable: boolean = undefined;
 
   /**
    * 事务
    */
   @property('Transactional')
-  // @ts-ignore
-  transactional!: Transactional;
+  transactional: Transactional = undefined;
+
+  /**
+   * 编译器信息
+   */
+  @property()
+  compilerInfoMap: { java?: { packageName: string; className: string } } = undefined;
 
   /**
    * 类型参数列表
@@ -154,36 +136,42 @@ export class Logic extends BaseNode {
   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
    */
@@ -195,11 +183,16 @@ export class Logic extends BaseNode {
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<Logic>) {
-    source = Object.assign({}, Logic.getDefaultOptions(), source);
+    // @ts-ignore
+    source = { ...Logic.getDefaultOptions(), ...source };
     super(source);
     super.subConstructor(source);
   }
 
+  getClassName() {
+    return 'Logic';
+  }
+
   static from(source: any, parentNode?: any, parentKey?: string): Logic {
     return super.from(source, parentNode, parentKey) as Logic;
   }
@@ -215,6 +208,7 @@ export class Logic extends BaseNode {
     }
     return params;
   }
+
   /**
    * 设置逻辑名称
    */
@@ -228,18 +222,6 @@ export class Logic extends BaseNode {
     });
   }
 
-  /**
-   * 设置逻辑标题
-   */
-  setTitle(title: string) {
-    const object = {
-      title,
-    };
-    this.update({
-      ...object,
-    });
-  }
-
   /**
    * 设置逻辑描述
    */
@@ -253,7 +235,7 @@ export class Logic extends BaseNode {
   }
 
   /**
-   * 设置触发方式
+   * 设置triggerType
    */
   setTriggerType(triggerType: string) {
     const object = {
@@ -265,7 +247,7 @@ export class Logic extends BaseNode {
   }
 
   /**
-   * 设置定时任务表达式
+   * 设置cron
    */
   setCron(cron: string) {
     const object = {
@@ -277,7 +259,7 @@ export class Logic extends BaseNode {
   }
 
   /**
-   * 设置是否可覆写
+   * 设置overridable
    */
   setOverridable(overridable: boolean) {
     const object = {
@@ -307,6 +289,7 @@ export class Logic extends BaseNode {
     const excludedSet = new Set(excludedList);
     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);
   }
@@ -343,7 +326,7 @@ export class Logic extends BaseNode {
           name: this.getTypeParamUniqueName(),
         },
         this,
-        'typeParams',
+        'typeParams'
       );
     } else if (typeof options === 'string') {
       typeParam = TypeParam.from(
@@ -352,7 +335,7 @@ export class Logic extends BaseNode {
           name: options,
         },
         this,
-        'typeParams',
+        'typeParams'
       );
     } else if (options instanceof TypeParam) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -365,7 +348,7 @@ export class Logic extends BaseNode {
           ...options,
         },
         this,
-        'typeParams',
+        'typeParams'
       );
     }
     this.typeParams.splice(index, 0, typeParam);
@@ -492,7 +475,7 @@ export class Logic extends BaseNode {
           name: this.getParamUniqueName(),
         },
         this,
-        'params',
+        'params'
       );
     } else if (typeof options === 'string') {
       param = Param.from(
@@ -501,7 +484,7 @@ export class Logic extends BaseNode {
           name: options,
         },
         this,
-        'params',
+        'params'
       );
     } else if (options instanceof Param) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -514,7 +497,7 @@ export class Logic extends BaseNode {
           ...options,
         },
         this,
-        'params',
+        'params'
       );
     }
     this.params.splice(index, 0, param);
@@ -641,7 +624,7 @@ export class Logic extends BaseNode {
           name: this.getReturnUniqueName(),
         },
         this,
-        'returns',
+        'returns'
       );
     } else if (typeof options === 'string') {
       ret = Return.from(
@@ -650,7 +633,7 @@ export class Logic extends BaseNode {
           name: options,
         },
         this,
-        'returns',
+        'returns'
       );
     } else if (options instanceof Return) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -663,7 +646,7 @@ export class Logic extends BaseNode {
           ...options,
         },
         this,
-        'returns',
+        'returns'
       );
     }
     this.returns.splice(index, 0, ret);
@@ -790,7 +773,7 @@ export class Logic extends BaseNode {
           name: this.getVariableUniqueName(),
         },
         this,
-        'variables',
+        'variables'
       );
     } else if (typeof options === 'string') {
       variable = Variable.from(
@@ -799,7 +782,7 @@ export class Logic extends BaseNode {
           name: options,
         },
         this,
-        'variables',
+        'variables'
       );
     } else if (options instanceof Variable) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -812,7 +795,7 @@ export class Logic extends BaseNode {
           ...options,
         },
         this,
-        'variables',
+        'variables'
       );
     }
     this.variables.splice(index, 0, variable);
@@ -932,7 +915,7 @@ export class Logic extends BaseNode {
           ...options,
         },
         this,
-        'body',
+        'body'
       );
     }
     this.body.splice(index, 0, logicItem);
@@ -1032,7 +1015,7 @@ export class Logic extends BaseNode {
           ...options,
         },
         this,
-        'playground',
+        'playground'
       );
     }
     this.playground.splice(index, 0, logicItem);
@@ -1120,7 +1103,7 @@ export class Logic extends BaseNode {
     if (typeof options === 'string') {
       transactional = this.transactional;
       if (!transactional) {
-        throw new Error('找不到事务 ' + options);
+        throw new Error(`找不到事务 ${options}`);
       }
     } else {
       transactional = options;
@@ -1129,7 +1112,7 @@ export class Logic extends BaseNode {
   }
 
   __removeTransactional(transactional: Transactional) {
-    const parentKey = transactional.parentKey;
+    const { parentKey } = transactional;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -1168,7 +1151,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;
@@ -1177,7 +1160,7 @@ export class Logic extends BaseNode {
   }
 
   __removeTypeParam(typeParam: TypeParam) {
-    const parentKey = typeParam.parentKey;
+    const { parentKey } = typeParam;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -1216,7 +1199,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;
@@ -1225,7 +1208,7 @@ export class Logic extends BaseNode {
   }
 
   __removeParam(param: Param) {
-    const parentKey = param.parentKey;
+    const { parentKey } = param;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -1264,7 +1247,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;
@@ -1273,7 +1256,7 @@ export class Logic extends BaseNode {
   }
 
   __removeReturn(ret: Return) {
-    const parentKey = ret.parentKey;
+    const { parentKey } = ret;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -1312,7 +1295,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;
@@ -1321,7 +1304,7 @@ export class Logic extends BaseNode {
   }
 
   __removeVariable(variable: Variable) {
-    const parentKey = variable.parentKey;
+    const { parentKey } = variable;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -1350,7 +1333,7 @@ export class Logic extends BaseNode {
   removeItemInBody(logicItem: LogicItem): void;
 
   removeItemInBody(options: LogicItem) {
-    let logicItem: LogicItem = options;
+    const logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
@@ -1361,12 +1344,12 @@ export class Logic extends BaseNode {
   removeItemInPlayground(logicItem: LogicItem): void;
 
   removeItemInPlayground(options: LogicItem) {
-    let logicItem: LogicItem = options;
+    const logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
   __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
+    const { parentKey } = logicItem;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -1388,10 +1371,10 @@ export class Logic extends BaseNode {
     return params;
   }
 
-  //================================================================================
+  //= ===============================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
-  //================================================================================
+  //= ===============================================================================
   // 用于calllogic树中定位是那个logic，回显
   get calleewholeKey() {
     return `${this.getNamespace()}.${this.name}`;
@@ -1434,7 +1417,7 @@ export class Logic extends BaseNode {
       {
         mode: 'anyObject',
         excludedKeySet: this.JSON_EXCLUDED_KEYS,
-      },
+      }
     );
 
     return result as LogicItem;
@@ -1457,9 +1440,6 @@ export class Logic extends BaseNode {
       varList.push(...this.variables);
     }
     if (this.view) {
-      // 页面下，变量名不可以跟逻辑名相同，会有js 翻译问题
-      varList.push(this);
-
       if (Array.isArray(this.view.params)) {
         varList.push(...this.view.params);
       }
@@ -1664,11 +1644,7 @@ export class Logic extends BaseNode {
           code += indent((state?.tabSize || 0) + 1);
           code += 'const __LogicEmpty: any = null;';
         }
-      } else if (
-        this.body.length <= 2 &&
-        !(this.parentNode instanceof Namespace) &&
-        !(this.parentNode instanceof Process)
-      ) {
+      } else if (this.body.length <= 2 && !(this.parentNode instanceof Namespace) && !(this.parentNode instanceof Process)) {
         code += indent((state?.tabSize || 0) + 1);
         code += `${indent(state?.tabSize || 0 + 4)}const __LogicEmpty: any = null;`;
       }
@@ -1731,9 +1707,7 @@ export class Logic extends BaseNode {
     this.traverseChildren((el) => {
       if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
         if (el instanceof Assignment) {
-          const advanceVar = this.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
+          const advanceVar = this.variables?.find((variable) => !variable.typeAnnotation && el.left?.name === variable.name);
           if (advanceVar && !advanceMap.get(advanceVar)) {
             advanceMap.set(advanceVar, el);
           }
@@ -1747,9 +1721,7 @@ export class Logic extends BaseNode {
               leftIndex.length === 1
                 ? el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
                 : el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            const advanceVar = this.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
+            const advanceVar = this.variables?.find((variable) => !variable.typeAnnotation && leftCode === variable.name);
             if (advanceVar && !advanceMap.get(advanceVar)) {
               advanceMap.set(advanceVar, el);
             }
@@ -1827,9 +1799,7 @@ export class Logic extends BaseNode {
               : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
           if (leftCode === node.name) {
             const rightNode: any =
-              rightIndex.length === 1
-                ? assignment.rights[rightIndex[0]]?.expression
-                : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
+              rightIndex.length === 1 ? assignment.rights[rightIndex[0]]?.expression : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
             // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
             if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && !rightNode.isAutoInfer())) {
               if (rightNode.concept === 'NewComposite' && rightNode.typeAnnotation?.typeKind === 'anonymousStructure') {
@@ -1849,24 +1819,15 @@ export class Logic extends BaseNode {
             }
           }
         });
-      } else if (
-        ['NewList', 'NewMap'].includes(assignment.right?.concept) &&
-        !(assignment.right as any)?.typeAnnotation
-      ) {
+      } else if (['NewList', 'NewMap'].includes(assignment.right?.concept) && !(assignment.right as any)?.typeAnnotation) {
         const rightNode: any = assignment.right;
         code += ' = ';
         code += rightNode.getInitCode(shiftState(state, code, { inline: true }));
-      } else if (
-        assignment.right?.concept === 'NewComposite' &&
-        (assignment.right as any)?.typeAnnotation?.typeKind === 'anonymousStructure'
-      ) {
+      } else if (assignment.right?.concept === 'NewComposite' && (assignment.right as any)?.typeAnnotation?.typeKind === 'anonymousStructure') {
         const rightNode: any = assignment.right;
         code += ' = ';
         code += rightNode.getInitCode(shiftState(state, code, { inline: true }));
-      } else if (
-        assignment.right?.concept === 'NewComposite' &&
-        (assignment.right as any)?.typeAnnotation?.typeKind === 'generic'
-      ) {
+      } else if (assignment.right?.concept === 'NewComposite' && (assignment.right as any)?.typeAnnotation?.typeKind === 'generic') {
         const rightNode: any = assignment.right;
         code += ' = ';
         code += rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }));
@@ -1880,18 +1841,10 @@ export class Logic extends BaseNode {
           code += ' = ';
           let rightCode = '';
           // 因为右侧枚举要赋值就得new 一下；
-          if (
-            rightNode &&
-            rightNode instanceof Identifier &&
-            rightNode.namespace &&
-            rightNode.namespace.endsWith('enums')
-          ) {
+          if (rightNode && rightNode instanceof Identifier && rightNode.namespace && rightNode.namespace.endsWith('enums')) {
             rightCode += 'new ';
           }
-          rightCode +=
-            rightNode && rightNode.toEmbeddedTS
-              ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true }))
-              : '__RIGHT__';
+          rightCode += rightNode && rightNode.toEmbeddedTS ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true })) : '__RIGHT__';
           code += this.getRightCode(rightCode, assignment, rightNode);
         }
       }
@@ -1930,6 +1883,140 @@ export class Logic extends BaseNode {
     return code;
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState(), prefix?: string, logicName?: string, currentNode?: BaseNode): string {
+
+    // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
+    let code = '';
+    if (currentNode === this) {
+      code += `\n${indent(state.tabSize)}/**
+${indent(state.tabSize)} * 当前逻辑
+${indent(state.tabSize)} */\n`;
+    }
+    if (!logicName) {
+      const { name, parentNode } = this;
+      if (parentNode?.concept === 'View') {
+          logicName = `viewLogic_${name}`;
+      } else if (parentNode?.concept === 'BindEvent') {
+          logicName = `on_${(parentNode?.parentNode)?.name}_${name}`;
+      } else {
+          logicName = this.name;
+      }
+    }
+
+    if (!prefix) {
+      code += `${indent(state.tabSize)}export ${currentNode !== this ? 'declare function' : 'function'} ${logicName}`;
+    } else if (prefix === 'noExport') {
+      code += `${indent(state.tabSize)}${currentNode !== this ? 'declare function' : 'function'} ${logicName}`;
+    } else if (prefix === 'inObject') {
+      code += `${logicName}`;
+    }
+    if (this.typeParams?.length) {
+      code += '<';
+      this.typeParams.forEach((typeParam, typeParamIndex) => {
+        code += typeParam.toNaturalTS(shiftState(state, code, { inline: true }));
+        if (typeParamIndex !== this.typeParams.length - 1)
+          code += ', ';
+      });
+      code += '>';
+    }
+    // 有参数长度
+    code += '(';
+    this.params.forEach((param, index) => {
+      code += param.toNaturalTS(shiftState(state, code, { inline: true }));
+      if (index !== this.params.length - 1)
+        code += ', ';
+    });
+
+    code += ')';
+
+    // 需要类型推导的局部变量/返回值需要调整申明顺序
+    const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
+    const needGetSourceMapOqlList: Promise<any>[] = [];
+    this.traverseChildren((el) => {
+      if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
+        const jsCode = el.toJS();
+        const advanceVar = this.variables?.find((variable) =>
+          !variable.typeAnnotation && jsCode.includes(`${variable.name} = `));
+        if (advanceVar && !advanceMap.get(advanceVar)) {
+          advanceMap.set(advanceVar, el);
+        }
+        const advanceRn = this.returns?.find((ret) =>
+          !ret.typeAnnotation && jsCode.includes(`${ret.name} = `));
+        if (advanceRn && !advanceMap.get(advanceRn)) {
+          advanceMap.set(advanceRn, el);
+        }
+      }
+      // 如果有sql查询组件就需要把他们存起来
+      if (el instanceof OqlQueryComponent) {
+        if (!el.codeSourceMap) {
+          needGetSourceMapOqlList.push(el.requestEmbeddedTS());
+        }
+      }
+    });
+
+    if (needGetSourceMapOqlList.length) {
+      Promise.all(needGetSourceMapOqlList).then(() => {
+        // 触发一下更新重新生成代码
+        (this.app as any)?.naslServer?.embeddedTSEmitter.emit('change', {
+          value: [{
+            originEvent: {
+              action: 'update',
+              target: this,
+            },
+          }],
+        });
+      });
+    }
+    // 兼容 return 没有类型情况
+    if (this.returns.length && this.returns[0].typeAnnotation) {
+      code += ': ';
+      code += this.returns[0].typeAnnotation?.toNaturalTS(shiftState(state, code, { inline: true }));
+    }
+
+    if (currentNode !== this) {
+      code += ';';
+    } else {
+      code += ' {\n';
+      this.variables.forEach((variable) => {
+        code += `${indent(state.tabSize + 1)}let `;
+        code += variable.toNaturalTS(shiftState(state, code, { inline: true }));
+        code += ';\n';
+      });
+  
+      this.returns.forEach((ret) => {
+        code += `${indent(state.tabSize + 1)}let `;
+        code += ret.toNaturalTS(shiftState(state, code, { inline: true }));
+        code += ';\n';
+      });
+  
+      code += `${indent(state.tabSize + 1)}// 当前位置\n`;
+      if (!this.body.length && this.returns.length) {
+        code += `${indent(state.tabSize + 1)}return ${this.returns[0].name};\n`;
+      } else {
+        this.body.forEach((item) => {
+          let partialCode = '';
+          if (item.toNaturalTS) {
+            partialCode = item.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+          } else if (item.toEmbeddedTS) {
+            partialCode = item.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+          }
+          if (partialCode.trim()) {
+            code += partialCode;
+            code += '\n';
+          }
+        });
+      }
+  
+      code += `${indent(state.tabSize)}}`;
+    }
+    if (prefix === 'inObject') {
+      code += `,`;
+    }
+    code += '\n';
+    return code;
+  }
+
   getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any): string {
     code = code.replaceAll('\n', ' ');
     if (assignment instanceof Assignment && !assignment.right) return code;
@@ -1982,11 +2069,7 @@ export class Logic extends BaseNode {
     const { item, index, each } = forEachStatement;
     if (code.includes(item.name)) {
       const eachTSCode = each.toEmbeddedTS();
-      code = this.handleReplaceCode(
-        code,
-        item.name,
-        eachTSCode === '__IDENTIFIER__' ? eachTSCode : `${eachTSCode}.__get(0)`,
-      );
+      code = this.handleReplaceCode(code, item.name, eachTSCode === '__IDENTIFIER__' ? eachTSCode : `${eachTSCode}.__get(0)`);
     }
     if (code.includes(index.name)) code = this.handleReplaceCode(code, index.name, 'new nasl.core.Long(0)');
 
@@ -2034,11 +2117,6 @@ export class Logic extends BaseNode {
         return parentNamespace;
       }
       const parentName = this.parentNode.name;
-      // 自定义连接器，增加了分组概念，故需要额外扩展一层namespace
-      const connector = this.getAncestor('Connector') as Connector;
-      if (connector && connector.connectorKind === 'app') {
-        return `${parentNamespace}.${parentName}`;
-      }
       const arr = [parentNamespace];
       if (this.parentNode.concept !== 'App' && parentName) {
         arr.push(parentName);
@@ -2069,8 +2147,6 @@ export class Logic extends BaseNode {
   getTsNamespace(): string {
     if (this.parentNode) {
       const parentNamespace = (this.parentNode as any)?.getTsNamespace();
-      // 对于parent类型为Namespace的情况，getTsNamespace 已经返回了具体的 name，
-      // 为什么下文还要重新获取？？？
       const parentName = this.parentNode.tsName || this.parentNode.name;
       const arr = [parentNamespace];
       if (this.parentNode.concept !== 'App' && parentName) {
@@ -2107,12 +2183,7 @@ export class Logic extends BaseNode {
     if (this.module) {
       _path = `/${this.module.parentKey}/${this.module.name}`;
     } else if (this.connector) {
-      // 自定义连接器有分组的概念因此，需要做文件夹处理
-      if (this.connector.connectorKind === 'app') {
-        _path = `/${this.connector.parentKey}/${this.connector.name}/${this.parentNode.name}`;
-      } else {
-        _path = `/${this.connector.parentKey}/${this.connector.name}`;
-      }
+      _path = `/${this.connector.parentKey}/${this.connector.name}`;
     }
     if (this.parentNode instanceof FrontendLibrary) {
       _path += `/frontends/${this.parentNode.type}`;
@@ -2177,7 +2248,7 @@ export class Logic extends BaseNode {
       {
         mode: 'anyObject',
         excludedKeySet: new Set(['parentNode', '__assignment__']),
-      },
+      }
     );
     for (const node of set) {
       (<CallQueryComponent>node).saveStructure();
@@ -2189,7 +2260,7 @@ export class Logic extends BaseNode {
     this.setTransactional(
       new Transactional({
         enabled: flag,
-      }),
+      })
     );
   }
 
@@ -2200,25 +2271,13 @@ export class Logic extends BaseNode {
   delete() {
     let actionMsg = '删除逻辑项';
     if (this.name) actionMsg += `“${this.name}”`;
+    this.app?.emit('logicDeleted', { actionMsg: this.nodePath})
     this.app?.emit('collect:start', {
       actionMsg,
     });
     super.delete();
-    this.traverseChildren(async (el) => {
+    this.traverseChildren((el) => {
       if (el?.concept === 'CallQueryComponent') (el as CallQueryComponent).removeStructure();
-      // 仅仅针对 自定义连接器下的 Loigc，其他需要界定边界
-      const connector: Connector | null = el?.getAncestor?.('Connector') as Connector;
-      if (['CallAuthInterface', 'CallInterface'].includes(el?.concept) && connector) {
-        const { calleeName } = el as CallInterface;
-        const targetInterface = connector.interfaces.find(i => i.name === calleeName);
-        if (targetInterface) {
-          const refs = await (this.app as any)?.naslServer?._isHaveRef(targetInterface);
-          // 如果只有两个引用，则必然为自身以及当前logic引用，需要删除此接口
-          if (refs?.length <= 2) {
-            targetInterface.delete();
-          }
-        }
-      }
     });
     this.app?.emit('collect:end');
   }
@@ -2311,22 +2370,21 @@ export class Logic extends BaseNode {
         findHasError = true;
       } else if (logicType.typeNamespace === 'nasl.core' && logicType.typeKind === 'union') {
         // 如果 logic 有 returns 而且，也有typeArguments的长度
-        findHasError = Boolean(
-          logicType.typeArguments?.find((item) => item?.typeNamespace === 'nasl.ui' && item?.typeName === 'Error'),
-        );
+        findHasError = Boolean(logicType.typeArguments?.find((item) => item?.typeNamespace === 'nasl.ui' && item?.typeName === 'Error'));
       }
     }
     return findHasError;
   }
 
-  //================================================================================
+  //= ===============================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-  //================================================================================
+  //= ===============================================================================
 }
 
+classMap.Logic = Logic;
 export default Logic;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================