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

package/src/common/BaseNode.ts

@@ -1,22 +1,17 @@
 import { at } from 'lodash';
 import { v4 as uuidv4 } from 'uuid';
 
-import { config } from '../config';
 import { SourceMap } from '../translator';
-import storageService from '../service/storage/service';
 import { getSourceFromMap } from '../service/storage/map';
-import { loadThen } from '../service/storage/storagePoint';
 
-import { EventEmitter, EventPayload, Params } from './EventEmitter';
 import * as utils from '../utils';
-import classMap from './classMap';
-import { action, circular, excludedInJSON, property, getConceptConstructor, getConceptPropertyMap } from '../decorators';
+import { EventEmitter, EventPayload, Params } from './EventEmitter';
+import { action, circular, excludedInJSON, property, getConceptConstructor, getConceptPropertyMap, classMap } from '../decorators';
 import { Diagnostic } from '../manager/diagnostic';
-import type { ViewElement, TypeAnnotation, App } from '..';
 
 import { sentryMonitorNaslNode } from '../sentry';
 import operations from '../breakpoint/shared/operations';
-import type { SynatxNode, SynatxNodeConcept } from '../concepts';
+import type { SyntaxNode, SyntaxNodeConcept, ViewElement, TypeAnnotation, App, Namespace } from '../concepts';
 
 // 确保属性都是定义过的
 function ensureDefined(object: any, concept: string) {
@@ -45,6 +40,8 @@ function ensureDefined(object: any, concept: string) {
         }
       }
     }
+
+    newObject.concept = actualConcept;
   }
   return newObject;
 }
@@ -55,6 +52,8 @@ function ensureDefined(object: any, concept: string) {
  */
 @sentryMonitorNaslNode
 export class BaseNode extends EventEmitter {
+  static readonly ConceptName: string = 'BaseNode';
+
   /**
    * 可修改标志，内部属性
    * 标记在构造函数结束后是否可修改
@@ -62,11 +61,28 @@ export class BaseNode extends EventEmitter {
   @excludedInJSON()
   _mutable = true;
 
+  /** 节点类别缓存 */
+  @excludedInJSON()
+  private _concept!: string;
+
   /**
    * 概念
    */
   @property()
-  concept: string = undefined;
+  get concept() {
+    return this._concept ?? (this.constructor as any).ConceptName as string;
+  }
+  set concept(val: string) {
+    console.warn(`[警告] 尽快移除变更 concept 值的操作，下个版本 concept 将会改为只读。\n当前变更：${this.concept} -> ${val}，原始节点类别：${(this.constructor as any).ConceptName}`);
+    if (val !== this.concept) {
+      if (val === (this.constructor as any).ConceptName as string) {
+        delete this._concept;
+      } else {
+        this._concept = val;
+      }
+    }
+  }
+
 
   /**
    * toJSON 时需要去除的键，为了避免出现 CircularJSON
@@ -82,22 +98,22 @@ export class BaseNode extends EventEmitter {
    * 变动时间
    */
   @property()
-  changedTime: number = undefined;
+  changedTime!: number;
 
   /**
    * 分支名称
    */
   @property()
-  branchName: string = undefined;
+  branchName!: string;
 
   /**
    * 合并代码相关
    */
   @property()
-  workingCopy: object = undefined;
+  workingCopy!: object;
 
   @property()
-  branch: object = undefined;
+  branch!: object;
 
   /**
    * 断点状态
@@ -107,13 +123,13 @@ export class BaseNode extends EventEmitter {
    * 'DISABLED' ==> 禁用断点
    */
   @property()
-  breakpoint: 'ENABLED' | 'DISABLED' | null | undefined = undefined;
+  breakpoint!: 'ENABLED' | 'DISABLED' | null | undefined;
 
   /**
    * 父节点
    */
   @circular()
-  parentNode: SynatxNode = null;
+  parentNode: SyntaxNode = null;
 
   parentKey: string = '';
 
@@ -122,91 +138,98 @@ export class BaseNode extends EventEmitter {
    * 前端 UI 状态
    */
   @excludedInJSON()
-  editable: boolean = undefined;
+  editable!: boolean;
 
   /**
    * 是否可以删除
    * 前端 UI 状态
    */
   @excludedInJSON()
-  removable: boolean = undefined;
+  removable!: boolean;
 
   /**
    * 是否正在编辑
    * 前端 UI 状态
    */
   @excludedInJSON()
-  editing: boolean = false;
+  editing!: boolean;
 
   /**
    * 是否正在请求
    * 前端 UI 状态
    */
   @excludedInJSON()
-  loading: boolean = false;
+  loading!: boolean;
 
   /**
    * 节点是否为展开状态
    * 前端 UI 状态
    */
   @excludedInJSON()
-  expanded: boolean = false;
+  expanded!: boolean;
 
   /**
    * 节点是否显示
    * 前端 UI 状态
    */
   @excludedInJSON()
-  hidden: boolean = false;
+  hidden!: boolean;
 
   /**
    * 页面树节点是否显示
    * 前端 UI 状态
    */
   @excludedInJSON()
-  pageTreeNodeHidden: boolean = false;
+  pageTreeNodeHidden!: boolean;
 
   /**
    * 逻辑树节点是否显示
    * 前端 UI 状态
    */
   @excludedInJSON()
-  logicTreeNodeHidden: boolean = false;
+  logicTreeNodeHidden!: boolean;
 
   /**
    * 数据树节点是否显示
    * 前端 UI 状态
    */
   @excludedInJSON()
-  dataTreeNodeHidden: boolean = false;
+  dataTreeNodeHidden!: boolean;
+
+    /**
+   * 数据树节点是否显示
+   * 前端 UI 状态
+   */
+  @excludedInJSON()
+  processTreeNodeHidden!: boolean;
 
   /**
    * 数据树节点是否展开
    * 前端 UI 状态
    */
   @excludedInJSON()
-  logicTreeNodeExpanded: boolean = false;
+  logicTreeNodeExpanded!: boolean;
 
   /**
    * 用于挂 embeddedTS 的 sourceMap
    */
   @excludedInJSON()
-  sourceMap: SourceMap = undefined;
+  sourceMap!: SourceMap;
 
   /**
    * 是否为叶子节点
    * 前端 UI 状态
    */
   @excludedInJSON()
-  isLeaf: boolean = false;
+  isLeaf!: boolean;
 
   @excludedInJSON()
-  storageJSON: any;
+  storageJSON!: any;
 
   /**
    * 当前节点上报错详细信息
    */
-  tsErrorDetail: Diagnostic | undefined = undefined;
+  tsErrorDetail!: Diagnostic | undefined;
 
   @property()
   name: string = '';
@@ -215,13 +238,13 @@ export class BaseNode extends EventEmitter {
    * 当前节点的类型标注
    */
   @excludedInJSON()
-  __TypeAnnotation: TypeAnnotation = undefined;
+  __TypeAnnotation!: TypeAnnotation;
 
   /**
    * 当前节点的类型标注是不是正确的
    */
   @excludedInJSON()
-  __isCorrectTypeAnnotation: boolean = false;
+  __isCorrectTypeAnnotation!: boolean;
 
   /**
    * @param source 需要合并的部分参数
@@ -242,26 +265,33 @@ export class BaseNode extends EventEmitter {
     this.on('create', () => operations.create(this));
     this.on('delete', () => operations.delete(this));
     this.on('update', () => operations.update(this));
-  }
 
-  // static constructorName = 'BaseNode'
-  getClassName() {
-    return 'BaseNode';
   }
 
   subConstructor(source?: Partial<BaseNode>) {
-    const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
+    const propertyMap = getConceptPropertyMap(this.concept || this.constructor.name);
     const properties = Array.from(new Set([...Object.keys(this), ...Object.keys(source)])).filter((key) => propertyMap.has(key));
 
     // 测试时用的标记属性
     if (process.env.NODE_ENV === 'testing') {
-      properties.push('__$Selected');
+      properties.push('__$Selected', '__TypeAnnotation');
     }
 
     properties.forEach((key) => {
-      const property = propertyMap.get(key);
+      if (key === 'concept') {
+        return;
+      }
+
       const sourceItem = (source as any)[key] !== undefined ? (source as any)[key] : (this as any)[key];
+
+      let property = propertyMap.get(key);
       let objectRefCtor: any;
+
+      // 测试环境下，类型节点由外部注入，所以需要在初始化的时候必须带上类型节点
+      if (process.env.NODE_ENV === 'testing' && key === '__TypeAnnotation' && sourceItem) {
+        property = { objectRef: 'TypeAnnotation' };
+      }
+
       try {
         if (property?.objectRef) {
           const arr = property.objectRef.split(' | ');
@@ -274,47 +304,31 @@ export class BaseNode extends EventEmitter {
             }
           }
         }
+
         // 数组的情况也在这里做掉了
-        (this as any)[key] =
-          objectRefCtor && sourceItem && !(sourceItem instanceof objectRefCtor) ? this.instantiateSub(sourceItem, key) : sourceItem;
+        const val = objectRefCtor && sourceItem && !(sourceItem instanceof objectRefCtor) ? this.instantiateSub(sourceItem, key) : sourceItem;
+
+        if (val !== undefined) {
+          (this as any)[key] = val;
+        }
       } catch (e) {
         // Function has non-object prototype 'undefined' in instanceof check
         if (!e.message.includes('Function has non-object prototype')) throw e;
       }
     });
+
     operations.create(this);
-    // if (config.storage.protocol === 'http' && loadThen[source.concept as 'App' | 'View']) {
-    //     const { childNodes } = loadThen[source.concept as 'App' | 'View'] || {};
-    //     const queryList = childNodes.map(({ field, concept }) => {
-    //         const path = [this.nodePath, field].join('.');
-    //         return {
-    //             path,
-    //             excludes: loadThen[concept as 'App' | 'View'].childNodes.map(({ field }) => field),
-    //         };
-    //     });
-    //     storageService
-    //         .batchQuery({
-    //             body: queryList,
-    //             headers: {
-    //                 appId: this.rootNode?.id || this.id,
-    //             },
-    //         })
-    //         .then((data: any) =>
-    //             data.forEach((sourceItem: any, index: number) => {
-    //                 const { field, concept } = childNodes[index];
-    //                 if (!sourceItem || (Array.isArray((this as any)[field]) && !Array.isArray(sourceItem))) {
-    //                     return;
-    //                 }
-    //                 const objectRefCtor = getConceptConstructor(concept);
-    //                 (this as any)[field] = objectRefCtor ? this.instantiateSub(sourceItem, field) : sourceItem;
-    //             }));
-    // }
+
+    // node 环境下需要删除当前节点的 concept 属性
+    if (utils.isNode && ('concept' in this) && !this.concept) {
+      Reflect.deleteProperty(this, 'concept');
+    }
   }
 
   fixInstantiate() {
-    const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
-
+    const propertyMap = getConceptPropertyMap(this.concept ?? this.constructor.name);
     const properties = Object.keys(this).filter((key) => propertyMap.has(key));
+
     properties.forEach((key) => {
       const property = propertyMap.get(key);
       const sourceItem = (this as any)[key];
@@ -386,9 +400,9 @@ export class BaseNode extends EventEmitter {
     }
   }
 
-  createNode({ parentNode, parentKey, index }: { parentNode: SynatxNode; parentKey: string; index: number }) {
+  createNode({ parentNode, parentKey, index }: { parentNode: SyntaxNode; parentKey: string; index: number }) {
     if (parentNode) {
-      const property = parentNode[parentKey as keyof SynatxNode];
+      const property = parentNode[parentKey as keyof SyntaxNode];
       if (Array.isArray(property) && index !== -1) {
         property.splice(index, 0, this);
       } else {
@@ -480,11 +494,19 @@ export class BaseNode extends EventEmitter {
       node.changeLinesLocation(this);
     }
 
+    // 自定义连接器下的namespace删除的时候需要同时删除对应的logic
+    if (this.concept === 'Namespace' && this.parentNode.concept === 'Connector') {
+      (this as unknown as Namespace).logics.forEach(logic => logic?.delete())
+    }
+
     const useIndex = ['BindEvent', 'Identifier'].includes(this.concept);
     const path = this.getNodePath(useIndex);
     const parentParams = this._delete();
     if (parentParams && parentParams.index !== -1) {
       if (Array.isArray((this.parentNode as any)[this.parentKey])) {
+        if (process.env.NODE_ENV === 'development') {
+          console.log('删除节点', this);
+        }
         this.emit('delete', {
           action: 'delete',
           path,
@@ -512,66 +534,97 @@ export class BaseNode extends EventEmitter {
    */
   update({ field, ...object }: any) {
     const path = this.getNodePath(false);
+    // 更新前的旧的对象
     const oldObject: any = {};
+    // 更新后的新对象
+    const newObject: any = {};
     for (const key in object) {
+      if (key === 'concept') {
+        continue;
+      }
       if (Object.prototype.hasOwnProperty.call(object, key)) {
-        const oldProperty = (this as any)[key] ?? null;
-        oldObject[key] = oldProperty;
-        if (Array.isArray(oldProperty)) {
-          oldObject[key] = oldProperty.map((item) => {
+        // 旧对象收集
+        this.collectOldObject(oldObject, key);
+        // 新对象收集
+        this.collectNewObject(newObject, object, key);
+      }
+    }
+
+    // 更新实例上的属性
+    this.updateInstance(object);
+
+    if (process.env.NODE_ENV === 'development') {
+      console.log('更新节点', 'path', path, 'oldObject', oldObject, 'newObject', newObject);
+    }
+    this.emit('update', {
+      action: 'update',
+      path,
+      object: newObject,
+      oldObject,
+      field,
+    });
+  }
+
+  // 旧对象收集
+  collectOldObject(oldObject: any, key: string) {
+    const oldProperty = (this as any)[key] ?? null;
+    oldObject[key] = oldProperty;
+    if (Array.isArray(oldProperty)) {
+        oldObject[key] = oldProperty.map((item) => {
             let propertyItem = item ?? null;
             if (item instanceof BaseNode) {
-              propertyItem = item.toJSON();
+                propertyItem = item.toJSON();
             }
             return propertyItem;
-          });
-        } else if (oldProperty instanceof BaseNode) {
-          oldObject[key] = oldProperty.toJSON();
-        }
-        const property = object[key] ?? null;
-        (this as any)[key] = property;
-        const objectRefCtor = getConceptConstructor(property?.concept);
-        if (Array.isArray(property)) {
-          (this as any)[key] = property.map((item) => {
-            let propertyItem = item ?? null;
-            const propertyObjectRefCtor = getConceptConstructor(item?.concept);
-            if (propertyObjectRefCtor?.from) {
-              propertyItem = (propertyObjectRefCtor as any).from(item, this, key);
-            }
-            return propertyItem;
-          });
-        } else if (objectRefCtor?.from) {
-          (this as any)[key] = (objectRefCtor as any).from(property, this, key);
-        }
-      }
+        });
+    } else if (oldProperty instanceof BaseNode) {
+        oldObject[key] = oldProperty.toJSON();
     }
-    const newObject: any = {};
-    const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
-    for (const key in object) {
-      const property = propertyMap.get(key);
-      if (property) {
+  }
+
+  // 新对象收集
+  collectNewObject(newObject: any, object: any, key: string) {
+    const propertyMap = getConceptPropertyMap(this.concept ?? this.constructor.name);
+    const property = propertyMap.get(key);
+    if (property) {
         const objProperty = object[key] ?? null;
         const propertyConcept = property?.objectRef;
         if (propertyConcept) {
-          if (Array.isArray(objProperty)) {
+        if (Array.isArray(objProperty)) {
             newObject[key] = objProperty.map((objItem: any) => {
-              return ensureDefined(objItem, propertyConcept);
+                return ensureDefined(objItem, propertyConcept);
             });
-          } else {
+        } else {
             newObject[key] = ensureDefined(objProperty, propertyConcept);
-          }
+        }
         } else {
-          newObject[key] = objProperty;
+            newObject[key] = objProperty;
         }
+    }
+  }
+
+  // 更新实例上的属性
+  updateInstance(object: any) {
+     for (const key in object) {
+      if (key === 'concept') {
+        continue;
+      }
+      const property = object[key] ?? null;
+      (this as any)[key] = property;
+      const objectRefCtor = getConceptConstructor(property?.concept);
+      if (Array.isArray(property)) {
+        (this as any)[key] = property.map((item) => {
+          let propertyItem = item ?? null;
+          const propertyObjectRefCtor = getConceptConstructor(item?.concept);
+          if (propertyObjectRefCtor?.from) {
+            propertyItem = (propertyObjectRefCtor as any).from(item, this, key);
+          }
+          return propertyItem;
+        });
+      } else if (objectRefCtor?.from) {
+        (this as any)[key] = (objectRefCtor as any).from(property, this, key);
       }
     }
-    this.emit('update', {
-      action: 'update',
-      path,
-      object: newObject,
-      oldObject,
-      field,
-    });
   }
 
   _delete(): Params {
@@ -586,7 +639,7 @@ export class BaseNode extends EventEmitter {
 
   static from(source: any, parentNode?: BaseNode, parentKey?: string): BaseNode {
     // 有一些继承的情况
-    const Ctor = classMap?.[source?.concept] || this;
+    const Ctor = classMap.get(source?.concept) || this;
     if (Ctor && source instanceof Ctor) {
       if (parentNode) {
         source.parentNode = parentNode;
@@ -607,7 +660,7 @@ export class BaseNode extends EventEmitter {
       }
       instance.subConstructor({
         ...source,
-        concept: source.concept || this?.prototype?.getClassName() || Ctor.name,
+        concept: source?.concept ?? this?.prototype?.concept ?? (Ctor as any).ConceptName as string ?? Ctor.name,
         parentNode,
       });
       return instance;
@@ -646,7 +699,13 @@ export class BaseNode extends EventEmitter {
               })
             : null;
           if (siblingNode || !name || (useIndex && isNodeSelf) || useIndexKeys.includes(node.concept)) {
-            const index = parentProperty.indexOf(node);
+            const index = parentProperty.findIndex((item) => {
+              if (item === node) {
+                return true;
+              }
+
+              return item?.id && item?.id === node?.id;
+            });
             path += `[${index}]`;
           } else {
             path += `[name=${name}]`;
@@ -664,13 +723,13 @@ export class BaseNode extends EventEmitter {
   /**
    * 上层节点
    */
-  get upperNode(): SynatxNode {
+  get upperNode(): SyntaxNode {
     // eslint-disable-next-line consistent-this
     let _upperNode: BaseNode = this;
     while (!!_upperNode && _upperNode.concept === this.concept) {
       _upperNode = _upperNode.parentNode;
     }
-    return _upperNode as SynatxNode;
+    return _upperNode as SyntaxNode;
   }
 
   /**
@@ -683,9 +742,9 @@ export class BaseNode extends EventEmitter {
   /**
    * 获取祖先节点
    */
-  getAncestor(concept: SynatxNode['concept']): SynatxNode;
-  getAncestor<Node extends SynatxNode>(concept: Node['concept']): Node;
-  getAncestor<Node extends SynatxNode = SynatxNode>(concept: SynatxNode['concept']): Node {
+  getAncestor(concept: SyntaxNode['concept']): SyntaxNode;
+  getAncestor<Node extends SyntaxNode>(concept: Node['concept']): Node;
+  getAncestor<Node extends SyntaxNode = SyntaxNode>(concept: SyntaxNode['concept']): Node {
     let { upperNode } = this;
     while (upperNode && upperNode.concept && upperNode.concept !== concept) {
       upperNode = upperNode.upperNode;
@@ -747,13 +806,13 @@ export class BaseNode extends EventEmitter {
   instantiate(source: any, parentNode: BaseNode, parentKey: string) {
     if (source instanceof BaseNode) {
       if (!source.parentNode || !source.parentKey) {
-        source.parentNode = parentNode as SynatxNode;
+        source.parentNode = parentNode as SyntaxNode;
         source.parentKey = parentKey;
       }
       return source;
     }
-    if (source && source.concept && classMap[source.concept]) {
-      const Ctor = classMap[source.concept] as any;
+    if (source && source.concept && classMap.get(source.concept)) {
+      const Ctor = classMap.get(source.concept) as any;
       const instance = Ctor.from(source, parentNode, parentKey);
       if (instance && instance.toStorageJSON) instance.storageJSON = instance.toStorageJSON();
       return instance;
@@ -770,7 +829,7 @@ export class BaseNode extends EventEmitter {
       return;
     }
     const completeList: any[] = [];
-    let isArray = false;
+    let isArray;
     // 暂时通过是否有name判断数据是否全
     if (Array.isArray(source)) {
       isArray = true;
@@ -848,7 +907,7 @@ export class BaseNode extends EventEmitter {
   }
 
   _toJSON(filerFn?: (source: Partial<BaseNode>) => {}): any {
-    const propertyMap = getConceptPropertyMap(this.getClassName() || this.constructor.name);
+    const propertyMap = getConceptPropertyMap(this.concept || this.constructor.name);
     const source: Partial<BaseNode> = {};
     propertyMap.forEach((property, key: string) => {
       if (property) {
@@ -861,6 +920,10 @@ export class BaseNode extends EventEmitter {
         }
       }
     });
+
+    // @ts-ignore
+    source.concept = this.concept;
+
     return filerFn ? filerFn(source) : source;
   }
 
@@ -1070,8 +1133,8 @@ export class BaseNode extends EventEmitter {
     return {};
   }
 
-  public traverseChildren(cb: (ele: SynatxNode) => void): void {
-    function traverse(node: SynatxNode) {
+  public traverseChildren(cb: (ele: SyntaxNode) => void): void {
+    function traverse(node: SyntaxNode) {
       cb(node);
 
       const propertyMap = getConceptPropertyMap(node?.concept);
@@ -1080,12 +1143,12 @@ export class BaseNode extends EventEmitter {
       for (const property of propertyMap.keys()) {
         const child = node[property as keyof BaseNode];
         if (!child) continue;
-        else if (Array.isArray(child)) child.forEach((node: SynatxNode) => traverse(node));
+        else if (Array.isArray(child)) child.forEach((node: SyntaxNode) => traverse(node));
         else traverse(child);
       }
     }
 
-    traverse(this as unknown as SynatxNode);
+    traverse(this as unknown as SyntaxNode);
   }
 
   /**
@@ -1176,14 +1239,36 @@ export class BaseNode extends EventEmitter {
     return null;
   }
 
+  /**
+   * 使用新的 concept 在当前节点生成新的数据
+   */
+  changeConceptNode(concept: SyntaxNodeConcept) {
+    return new Proxy(this, {
+      get(target, p: keyof BaseNode, receiver) {
+          if (p === 'concept') {
+            return concept;
+          }
+
+          return target[p];
+      },
+    })
+  }
+
+  /** 收集所有节点 */
+  collectNodes(): SyntaxNode[];
   /** 收集特定类型的子节点 */
-  collectNodes(concept: SynatxNodeConcept): void;
-  /** 收集判定为真的子节点 */
-  collectNodes(pre: (node: SynatxNode) => boolean): void;
-  collectNodes(input: SynatxNodeConcept | ((node: SynatxNode) => boolean)) {
-    const pre = typeof input === 'string' ? (node: SynatxNode) => node.concept === input : input;
-    const nodes: SynatxNode[] = [];
-    const self = this as unknown as SynatxNode;
+  collectNodes(concept: SyntaxNodeConcept): SyntaxNode[];
+  /** 收集断言返回`true`的子节点 */
+  collectNodes(pre: (node: SyntaxNode) => boolean): SyntaxNode[];
+  collectNodes(input?: SyntaxNodeConcept | ((node: SyntaxNode) => boolean)) {
+    const pre =
+      typeof input === 'undefined'
+        ? (node: SyntaxNode) => typeof node.concept === 'string'
+        : typeof input === 'string'
+          ? (node: SyntaxNode) => node.concept === input
+          : input;
+    const nodes: SyntaxNode[] = [];
+    const self = this as unknown as SyntaxNode;
 
     if (pre(self)) {
       nodes.push(self);