@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/concepts/EntityProperty__.ts

@@ -1,19 +1,18 @@
+import { v4 as uuidv4 } from 'uuid';
 import { dataTypesMap } from './basics/types';
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
-type changeType = 'up' | 'down';
 import CallQueryComponent from './CallQueryComponent__';
 import StructureProperty from './StructureProperty__';
 import Structure from './Structure__';
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
 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 TypeAnnotation from './TypeAnnotation__';
@@ -23,809 +22,844 @@ import Module from './Module__';
 import App from './App__';
 import DataSource from './DataSource__';
 
+type changeType = 'up' | 'down';
+
 /**
  * 实体属性
  */
 @concept('实体属性')
 export class EntityProperty extends BaseNode {
-    /**
-     * 产品概念
-     */
-    @property()
-    concept: 'EntityProperty' = 'EntityProperty';
-
-    /**
-     * 实体属性名称
-     */
-    @property()
-    name: string = undefined;
-
-    /**
-     * 唯一标识
-     */
-    @property()
-    uuid: string = uuidv4().replace(/-/g, '');
-
-    /**
-     * 数据库列名
-     */
-    @property()
-    columnName: string = undefined;
-
-    /**
-     * 实体属性标题
-     */
-    @property()
-    label: string = undefined;
-
-    /**
-     * 实体属性描述
-     */
-    @property()
-    description: string = undefined;
-
-    /**
-     * 类型
-     */
-    @property('TypeAnnotation')
-    typeAnnotation: TypeAnnotation = undefined;
-
-    /**
-     * 数据库存储类型
-     */
-    @property('DatabaseTypeAnnotation')
-    databaseTypeAnnotation: DatabaseTypeAnnotation = undefined;
-
-    /**
-     * 是否必填
-     */
-    @property()
-    required: boolean = undefined;
-
-    /**
-     * 默认值
-     */
-    @property()
-    defaultValue: string = undefined;
-
-    /**
-     * 当前属性是否为主键
-     */
-    @property()
-    primaryKey: boolean = undefined;
-
-    /**
-     * 关联实体的命名空间
-     */
-    @property()
-    relationNamespace: string = undefined;
-
-    /**
-     * 关联实体
-     */
-    @property()
-    relationEntity: string = undefined;
-
-    /**
-     * 关联属性
-     */
-    @property()
-    relationProperty: string = undefined;
-
-    /**
-     * 关联属性实体记录删除规则
-     */
-    @property()
-    deleteRule: 'protect' | 'cascade' = undefined;
-
-    /**
-     * 显示方式
-     */
-    @property()
-    display: { [name: string]: boolean } = {
-        inDetail: true,
-        inFilter: true,
-        inForm: true,
-        inTable: true,
+  /**
+   * 产品概念
+   */
+  @property()
+  concept: 'EntityProperty' = 'EntityProperty';
+
+  /**
+   * 实体属性名称
+   */
+  @property()
+  name: string = undefined;
+
+  /**
+   * 唯一标识
+   */
+  @property()
+  uuid: string = uuidv4().replace(/-/g, '');
+
+  /**
+   * 数据库列名
+   */
+  @property()
+  columnName: string = undefined;
+
+  /**
+   * 实体属性标题
+   */
+  @property()
+  label: string = undefined;
+
+  /**
+   * 实体属性描述
+   */
+  @property()
+  description: string = undefined;
+
+  /**
+   * 类型
+   */
+  @property('TypeAnnotation')
+  typeAnnotation: TypeAnnotation = undefined;
+
+  /**
+   * 数据库存储类型
+   */
+  @property('DatabaseTypeAnnotation')
+  databaseTypeAnnotation: DatabaseTypeAnnotation = undefined;
+
+  /**
+   * 是否必填
+   */
+  @property()
+  required: boolean = undefined;
+
+  /**
+   * 默认值
+   */
+  @property()
+  defaultValue: string = undefined;
+
+  /**
+   * 当前属性是否为主键
+   */
+  @property()
+  primaryKey: boolean = undefined;
+
+  /**
+   * 关联实体的命名空间
+   */
+  @property()
+  relationNamespace: string = undefined;
+
+  /**
+   * 关联实体
+   */
+  @property()
+  relationEntity: string = undefined;
+
+  /**
+   * 关联属性
+   */
+  @property()
+  relationProperty: string = undefined;
+
+  /**
+   * 关联属性实体记录删除规则
+   */
+  @property()
+  deleteRule: 'protect' | 'cascade' = undefined;
+
+  /**
+   * 显示方式
+   */
+  @property()
+  display: { [name: string]: boolean } = {
+    inDetail: true,
+    inFilter: true,
+    inForm: true,
+    inTable: true,
+  };
+
+  /**
+   * 验证规则
+   */
+  @property()
+  rules: Array<string> = [];
+
+  /**
+   * 生成规则
+   */
+  @property()
+  generationRule: 'auto' | 'autoIncrement' | 'manual' = 'auto';
+
+  /**
+   * 表示 Oracle 主键自增时的序列名称
+   */
+  @property()
+  sequence: string = undefined;
+
+  /**
+   * 祖先 Entity
+   */
+  get entity() {
+    return this.getAncestor('Entity') as Entity;
+  }
+
+  /**
+   * 祖先 Module
+   */
+  get module() {
+    return this.getAncestor('Module') as Module;
+  }
+
+  /**
+   * 祖先 App
+   */
+  get app() {
+    return this.getAncestor('App') as App;
+  }
+
+  /**
+   * 祖先 DataSource
+   */
+  get dataSource() {
+    return this.getAncestor('DataSource') as DataSource;
+  }
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<EntityProperty>) {
+    // @ts-ignore
+    source = { ...EntityProperty.getDefaultOptions(), ...source };
+    super(source);
+    super.subConstructor(source);
+  }
+
+  getClassName() {
+    return 'EntityProperty';
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): EntityProperty {
+    return super.from(source, parentNode, parentKey) as EntityProperty;
+  }
+
+  /**
+   * 从父级删除该节点
+   * @internal
+   */
+  _delete() {
+    let params: Params = null;
+    if (this.parentNode) {
+      params = (this.parentNode as any)?.__removeEntityProperty?.(this);
+    }
+    return params;
+  }
+
+  /**
+   * 设置实体属性标题
+   */
+  setLabel(label: string) {
+    const object = {
+      label,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置实体属性描述
+   */
+  setDescription(description: string) {
+    const object = {
+      description,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置数据库存储类型
+   */
+  setDatabaseTypeAnnotation(databaseTypeAnnotation: DatabaseTypeAnnotation) {
+    databaseTypeAnnotation._delete();
+    const relationOptions = { parentNode: this, parentKey: 'databaseTypeAnnotation' };
+    Object.assign(databaseTypeAnnotation, relationOptions);
+    const object = {
+      databaseTypeAnnotation,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置是否必填
+   */
+  setRequired(required: boolean) {
+    const object = {
+      required,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置默认值
+   */
+  setDefaultValue(defaultValue: string) {
+    const object = {
+      defaultValue,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置当前属性是否为主键
+   */
+  setPrimaryKey(primaryKey: boolean) {
+    const object = {
+      primaryKey,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置生成规则
+   */
+  setGenerationRule(generationRule: 'auto' | 'autoIncrement' | 'manual') {
+    const object = {
+      generationRule,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 删除类型标注
+   * @param name 类型标注名称
+   */
+  removeTypeAnnotation(name: string): void;
+
+  /**
+   * 删除类型标注
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
+
+  removeTypeAnnotation(options: string | TypeAnnotation) {
+    let typeAnnotation: TypeAnnotation;
+    if (typeof options === 'string') {
+      typeAnnotation = this.typeAnnotation;
+      if (!typeAnnotation) {
+        throw new Error(`找不到类型标注 ${options}`);
+      }
+    } else {
+      typeAnnotation = options;
+    }
+    return typeAnnotation.delete();
+  }
+
+  __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
+    const { parentKey } = typeAnnotation;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: typeAnnotation,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(typeAnnotation);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === typeAnnotation) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除数据库存储类型
+   * @param name 数据库存储类型名称
+   */
+  removeDatabaseTypeAnnotation(name: string): void;
+
+  /**
+   * 删除数据库存储类型
+   * @param databaseTypeAnnotation 已有的数据库存储类型实例
+   */
+  removeDatabaseTypeAnnotation(databaseTypeAnnotation: DatabaseTypeAnnotation): void;
+
+  removeDatabaseTypeAnnotation(options: string | DatabaseTypeAnnotation) {
+    let databaseTypeAnnotation: DatabaseTypeAnnotation;
+    if (typeof options === 'string') {
+      databaseTypeAnnotation = this.databaseTypeAnnotation;
+      if (!databaseTypeAnnotation) {
+        throw new Error(`找不到数据库存储类型 ${options}`);
+      }
+    } else {
+      databaseTypeAnnotation = options;
+    }
+    return databaseTypeAnnotation.delete();
+  }
+
+  __removeDatabaseTypeAnnotation(databaseTypeAnnotation: DatabaseTypeAnnotation) {
+    const { parentKey } = databaseTypeAnnotation;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: databaseTypeAnnotation,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(databaseTypeAnnotation);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === databaseTypeAnnotation) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  //= ===============================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //= ===============================================================================
+
+  /**
+   * 设置实体属性名称
+   */
+  async setName(name: string) {
+    const object: any = {
+      name,
     };
 
-    /**
-     * 验证规则
-     */
-    @property()
-    rules: Array<string> = [];
-
-    /**
-     * 生成规则
-     */
-    @property()
-    generationRule: 'auto' | 'autoIncrement' | 'manual' = 'auto';
-
-    /**
-     * 表示 Oracle 主键自增时的序列名称
-     */
-    @property()
-    sequence: string = undefined;
-
-    /**
-     * 祖先 Entity
-     */
-    get entity() {
-        return this.getAncestor('Entity') as Entity;
-    }
-    /**
-     * 祖先 Module
-     */
-    get module() {
-        return this.getAncestor('Module') as Module;
-    }
-    /**
-     * 祖先 App
-     */
-    get app() {
-        return this.getAncestor('App') as App;
-    }
-    /**
-     * 祖先 DataSource
-     */
-    get dataSource() {
-        return this.getAncestor('DataSource') as DataSource;
-    }
-
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source?: Partial<EntityProperty>) {
-        source = Object.assign({}, EntityProperty.getDefaultOptions(), source);
-        super(source);
-        super.subConstructor(source);
-    }
-    getClassName() {
-        return 'EntityProperty';
-    }
-
-    static from(source: any, parentNode?: any, parentKey?: string): EntityProperty {
-        return super.from(source, parentNode, parentKey) as EntityProperty;
-    }
-
-    /**
-     * 从父级删除该节点
-     * @internal
-     */
-    _delete() {
-        let params: Params = null;
-        if (this.parentNode) {
-            params = (this.parentNode as any)?.__removeEntityProperty?.(this);
-        }
-        return params;
-    }
-    /**
-     * 设置实体属性标题
-     */
-    setLabel(label: string) {
-        const object = {
-            label,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-     * 设置实体属性描述
-     */
-    setDescription(description: string) {
-        const object = {
-            description,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-     * 设置数据库存储类型
-     */
-    setDatabaseTypeAnnotation(databaseTypeAnnotation: DatabaseTypeAnnotation) {
-        databaseTypeAnnotation._delete();
-        const relationOptions = { parentNode: this, parentKey: 'databaseTypeAnnotation' };
-        Object.assign(databaseTypeAnnotation, relationOptions);
-        const object = {
-            databaseTypeAnnotation,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-     * 设置是否必填
-     */
-    setRequired(required: boolean) {
-        const object = {
-            required,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-     * 设置默认值
-     */
-    setDefaultValue(defaultValue: string) {
-        const object = {
-            defaultValue,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-     * 设置当前属性是否为主键
-     */
-    setPrimaryKey(primaryKey: boolean) {
-        const object = {
-            primaryKey,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-     * 设置生成规则
-     */
-    setGenerationRule(generationRule: 'auto' | 'autoIncrement' | 'manual') {
-        const object = {
-            generationRule,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-    * 删除类型标注
-    * @param name 类型标注名称
-    */
-    removeTypeAnnotation(name: string): void;
-
-    /**
-     * 删除类型标注
-     * @param typeAnnotation 已有的类型标注实例
-     */
-    removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
-
-    removeTypeAnnotation(options: string | TypeAnnotation) {
-        let typeAnnotation: TypeAnnotation;
-        if (typeof options === 'string') {
-            typeAnnotation = this.typeAnnotation;
-            if (!typeAnnotation) {
-                throw new Error('找不到类型标注 ' + options);
-            }
+    // 列名为初始化时需赋值为属性名，同时需要与其他列名中去重
+    if ((this as any).__columnNameInit === false) {
+      delete (this as any).__columnNameInit;
+      const columnNames = (this.parentNode as Entity).properties.filter((item) => item !== this).map((item) => item.columnName);
+      const columnName = utils.unique(name, columnNames, undefined, false);
+      object.columnName = columnName;
+
+      this.update({
+        ...object,
+        field: 'name',
+      });
+      return;
+    }
+
+    // 根据 name 格式化列名
+    const oldName = this.name;
+    const oldColumnName = this.columnName;
+    this.name = name;
+    this.columnName = name;
+    this.__formatColumnName();
+    if (this.columnName !== oldColumnName && !(this.parentNode as Entity).isIgnoreFormatTableAndColumnName()) {
+      object.columnName = this.columnName;
+    }
+
+    this.name = oldName;
+    this.columnName = oldColumnName;
+    this.app?.emit('collect:start', { actionMsg: '修改实体属性名' });
+    this.update({
+      ...object,
+      field: 'name',
+    });
+    await this._effect();
+    this.app?.emit('collect:end');
+  }
+
+  /**
+   * 设置数据库列名
+   */
+  setColumnName(columnName: string) {
+    const object = {
+      columnName,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  async delete() {
+    let actionMsg = '删除实体属性';
+    if (this.name) actionMsg += `“${this.name}”`;
+    this.app?.emit('collect:start', { actionMsg });
+    // 副作用
+    await this._effect({ action: 'delete' });
+    super.delete();
+    this.app?.emit('collect:end');
+  }
+
+  async _effect(options: { action?: 'delete' } = {}) {
+    // 处理选中的此字段的 CallQueryComponent
+    const callQueryComponents: Set<CallQueryComponent> = new Set();
+    const refs = await this.findUsage();
+    refs.forEach((val: any) => {
+      const loopFindNode = (item: any) => {
+        if (item.children) {
+          item.children.forEach((i: any) => loopFindNode(i));
         } else {
-            typeAnnotation = options;
+          const target = item.node?.getAncestor('CallQueryComponent');
+          if (target) {
+            callQueryComponents.add(target);
+          }
         }
-        return typeAnnotation.delete();
-    }
-
-    __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
-        const parentKey = typeAnnotation.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: typeAnnotation,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(typeAnnotation);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === typeAnnotation) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
+      };
+      loopFindNode(val);
+    });
+    callQueryComponents?.forEach((node) => {
+      const targetField = node.select.selectFieldElements.find(
+        (item) => item.entityAsName === this.parentNode.name && item.propertyName === this.name
+      );
+      if (targetField) {
+        if (options.action === 'delete') {
+          // 删除字段对应的 QueryFieldExpression
+          targetField.delete();
         }
-        return params;
-    }
-
-    /**
-    * 删除数据库存储类型
-    * @param name 数据库存储类型名称
-    */
-    removeDatabaseTypeAnnotation(name: string): void;
-
-    /**
-     * 删除数据库存储类型
-     * @param databaseTypeAnnotation 已有的数据库存储类型实例
-     */
-    removeDatabaseTypeAnnotation(databaseTypeAnnotation: DatabaseTypeAnnotation): void;
-
-    removeDatabaseTypeAnnotation(options: string | DatabaseTypeAnnotation) {
-        let databaseTypeAnnotation: DatabaseTypeAnnotation;
-        if (typeof options === 'string') {
-            databaseTypeAnnotation = this.databaseTypeAnnotation;
-            if (!databaseTypeAnnotation) {
-                throw new Error('找不到数据库存储类型 ' + options);
-            }
-        } else {
-            databaseTypeAnnotation = options;
-        }
-        return databaseTypeAnnotation.delete();
-    }
-
-    __removeDatabaseTypeAnnotation(databaseTypeAnnotation: DatabaseTypeAnnotation) {
-        const parentKey = databaseTypeAnnotation.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: databaseTypeAnnotation,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(databaseTypeAnnotation);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === databaseTypeAnnotation) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-    //================================================================================
-    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-    // 自动生成的代码已结束。下面可以手动编写。
-    //================================================================================
-
-    /**
-     * 设置实体属性名称
-     */
-    async setName(name: string) {
-        const object: any = {
-            name,
-        };
-
-        // 列名为初始化时需赋值为属性名，同时需要与其他列名中去重
-        if ((this as any).__columnNameInit === false) {
-            delete (this as any).__columnNameInit;
-            const columnNames = (this.parentNode as Entity).properties.filter((item) => item !== this).map((item) => item.columnName);
-            const columnName = utils.unique(name, columnNames, undefined, false);
-            object.columnName = columnName;
-
-            this.update({
-                ...object,
-                field: 'name',
-            });
-            return;
-        }
-
-        // 根据 name 格式化列名
-        const oldName = this.name;
-        const oldColumnName = this.columnName;
-        this.name = name;
-        this.columnName = name;
-        this.__formatColumnName();
-        if (this.columnName !== oldColumnName && !(this.parentNode as Entity).isIgnoreFormatTableAndColumnName()) {
-            object.columnName = this.columnName;
-        }
-
-        this.name = oldName;
-        this.columnName = oldColumnName;
-        this.app?.emit('collect:start', { actionMsg: '修改实体属性名' });
-        this.update({
-            ...object,
-            field: 'name',
-        });
-        await this._effect();
-        this.app?.emit('collect:end');
-    }
-
-    /**
-     * 设置数据库列名
-     */
-    setColumnName(columnName: string) {
-        const object = {
-            columnName,
-        };
-        this.update({
-            ...object,
-        });
-    }
-    async delete() {
-        let actionMsg = '删除实体属性';
-        if (this.name)
-            actionMsg += `“${this.name}”`;
-        this.app?.emit('collect:start', { actionMsg });
-        // 副作用
-        await this._effect({ action: 'delete' });
-        super.delete();
-        this.app?.emit('collect:end');
-    }
-
-    async _effect(options: { action?: 'delete' } = {}) {
-        // 处理选中的此字段的 CallQueryComponent
-        const callQueryComponents: Set<CallQueryComponent> = new Set();
-        const refs = await this.findUsage();
-        refs.forEach((val: any) => {
-            const loopFindNode = (item: any) => {
-                if (item.children) {
-                    item.children.forEach((i: any) => loopFindNode(i));
-                } else {
-                    const target = item.node?.getAncestor('CallQueryComponent');
-                    if (target) {
-                        callQueryComponents.add(target);
-                    }
-                }
-            };
-            loopFindNode(val);
-        });
-        callQueryComponents?.forEach((node) => {
-            const targetField = node.select.selectFieldElements.find((item) => item.entityAsName === this.parentNode.name && item.propertyName === this.name);
-            if (targetField) {
-                if (options.action === 'delete') {
-                    // 删除字段对应的 QueryFieldExpression
-                    targetField.delete();
-                }
-                // 更新数据结构
-                node.saveStructure();
-            }
-        });
-    }
-    /**
-     * 是否展开
-     */
-    @property()
-    isLeaf: boolean = true;
-
-    /**
-     * 设置是否必填
-     */
-    setSequence(sequence: string) {
-        const object = {
-            sequence,
-        };
-        this.update({
-            ...object,
-        });
-    }
-    /**
-     * 设置是否必填
-     */
-    setDisplay(display: { [name: string]: boolean }) {
-        const object = {
-            display,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    setDeleteRule(deleteRule: string) {
-        const object = {
-            deleteRule,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-     * 根据全局设置中的数据库命名规则，生成 属性列名
-     */
-    genFormatColumnName() {
-        return (this.parentNode as Entity).genFormatPropertyColumnName(this);
-    }
-
-    /**
-     * 根据全局设置中的数据库命名规则，将 属性列名 重命名
-     * 此方法不会 update
-     */
-    __formatColumnName() {
-        const parentNode = this.parentNode as Entity;
-        if (parentNode.isIgnoreFormatTableAndColumnName()) {
-            // if (!this.columnName) {
-            //     this.columnName = this.name;
-            // }
-            return;
-        }
-
-        const newColumnName = this.genFormatColumnName();
-        if (newColumnName && (!this.columnName || (this.columnName && newColumnName !== this.columnName))) {
-            this.columnName = newColumnName;
-        }
-    }
-    /**
-     * 根据全局设置中的数据库命名规则，将 属性列名 重命名
-     */
-    formatColumnName() {
-        const parentNode = this.parentNode as Entity;
-        if (parentNode.isIgnoreFormatTableAndColumnName()) {
-            // if (!this.columnName) {
-            //     this.setColumnName(this.name);
-            // }
-            return;
-        }
-
-        const newColumnName = this.genFormatColumnName();
-        if (newColumnName && (!this.columnName || (this.columnName && newColumnName !== this.columnName))) {
-            this.setColumnName(newColumnName);
-        }
-    }
-
-    @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
-        let code = '';
-        if (this.relationNamespace && this.relationEntity && this.relationProperty) {
-            code += `@nasl.annotation.EntityRelation(new ${this.relationNamespace}.${this.relationEntity}().${this.relationProperty})\n`;
-            code += indent((state?.tabSize || 0) + 2);
-            // code += indent((state?.tabSize || 0) + 1);
-        }
-
-        code += this.name;
-        if (this.typeAnnotation) {
-            code += ': ';
-            code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
-        }
-        if (this.defaultValue) {
-            code += '= ' + this.typeAnnotation.getDefaultValue(this.defaultValue);
-        }
-        return code;
-    }
-    /**
-     * 设置数据类型
-     * @param typeAnnotation 类型标注对象
-     */
-    setDataType(typeAnnotation: TypeAnnotation): void;
-    /**
-     * 设置数据类型
-     * @param typeAnnotation 类型唯一标识
-     */
-    setDataType(typeKey: string): void;
-    setDataType(typeAnnotation: TypeAnnotation | string) {
-        if (typeof typeAnnotation === 'string') {
-            typeAnnotation = dataTypesMap[typeAnnotation];
-            if (!typeAnnotation)
-                // eslint-disable-next-line prefer-rest-params
-                throw new Error('找不到类型：' + arguments[0]);
-        } else {
-            typeAnnotation._delete?.();
-            const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
-            Object.assign(typeAnnotation, relationOptions);
-        }
-        const object = {
-            typeAnnotation,
-        };
-        return this.update({
-            ...object,
-        });
-    }
-
-    public static getDefaultOptions() {
+        // 更新数据结构
+        node.saveStructure();
+      }
+    });
+  }
+
+  /**
+   * 是否展开
+   */
+  @property()
+  isLeaf: boolean = true;
+
+  /**
+   * 设置是否必填
+   */
+  setSequence(sequence: string) {
+    const object = {
+      sequence,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置是否必填
+   */
+  setDisplay(display: { [name: string]: boolean }) {
+    const object = {
+      display,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  setDeleteRule(deleteRule: string) {
+    const object = {
+      deleteRule,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 根据全局设置中的数据库命名规则，生成 属性列名
+   */
+  genFormatColumnName() {
+    return (this.parentNode as Entity).genFormatPropertyColumnName(this);
+  }
+
+  /**
+   * 根据全局设置中的数据库命名规则，将 属性列名 重命名
+   * 此方法不会 update
+   */
+  __formatColumnName() {
+    const parentNode = this.parentNode as Entity;
+    if (parentNode.isIgnoreFormatTableAndColumnName()) {
+      // if (!this.columnName) {
+      //     this.columnName = this.name;
+      // }
+      return;
+    }
+
+    const newColumnName = this.genFormatColumnName();
+    if (newColumnName && (!this.columnName || (this.columnName && newColumnName !== this.columnName))) {
+      this.columnName = newColumnName;
+    }
+  }
+
+  /**
+   * 根据全局设置中的数据库命名规则，将 属性列名 重命名
+   */
+  formatColumnName() {
+    const parentNode = this.parentNode as Entity;
+    if (parentNode.isIgnoreFormatTableAndColumnName()) {
+      // if (!this.columnName) {
+      //     this.setColumnName(this.name);
+      // }
+      return;
+    }
+
+    const newColumnName = this.genFormatColumnName();
+    if (newColumnName && (!this.columnName || (this.columnName && newColumnName !== this.columnName))) {
+      this.setColumnName(newColumnName);
+    }
+  }
+
+  @withSourceMap()
+  toEmbeddedTS(state?: TranslatorState): string {
+    let code = '';
+    if (this.relationNamespace && this.relationEntity && this.relationProperty) {
+      code += `@nasl.annotation.EntityRelation(new ${this.relationNamespace}.${this.relationEntity}().${this.relationProperty})\n`;
+      code += indent((state?.tabSize || 0) + 2);
+      // code += indent((state?.tabSize || 0) + 1);
+    }
+
+    code += this.name;
+    if (this.typeAnnotation) {
+      code += ': ';
+      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+    }
+    if (this.defaultValue) {
+      code += `= ${this.typeAnnotation.getDefaultValue(this.defaultValue)}`;
+    }
+    return code;
+  }
+
+  @withSourceMap()
+  toNaturalTS(state?: TranslatorState): string {
+    let code = '';
+    if (this.relationNamespace && this.relationEntity && this.relationProperty) {
+      code += `@EntityRelation(() => new ${this.relationEntity}().${this.relationProperty})\n`;
+      code += indent(state.tabSize);
+    }
+
+    code += this.name;
+    if (this.typeAnnotation) {
+      code += ': ';
+      code += this.typeAnnotation.toNaturalTS(shiftState(state, code, { inline: true }));
+    }
+    return code;
+  }
+
+  /**
+   * 设置数据类型
+   * @param typeAnnotation 类型标注对象
+   */
+  setDataType(typeAnnotation: TypeAnnotation): void;
+  /**
+   * 设置数据类型
+   * @param typeAnnotation 类型唯一标识
+   */
+  setDataType(typeKey: string): void;
+  setDataType(typeAnnotation: TypeAnnotation | string) {
+    if (typeof typeAnnotation === 'string') {
+      typeAnnotation = dataTypesMap[typeAnnotation];
+      if (!typeAnnotation)
+        // eslint-disable-next-line prefer-rest-params
+        throw new Error(`找不到类型：${arguments[0]}`);
+    } else {
+      typeAnnotation._delete?.();
+      const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
+      Object.assign(typeAnnotation, relationOptions);
+    }
+    const object = {
+      typeAnnotation,
+    };
+    return this.update({
+      ...object,
+    });
+  }
+
+  public static getDefaultOptions() {
+    return {
+      typeAnnotation: {
+        concept: 'TypeAnnotation',
+        typeKind: 'primitive',
+        typeNamespace: 'nasl.core',
+        typeName: 'String',
+      },
+    };
+  }
+
+  /**
+   * 关联属性
+   */
+  clearReference() {
+    const object = {
+      relationEntity: null as string,
+      relationProperty: null as string,
+      relationNamespace: null as string,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 属性上移
+   */
+  moveUp() {
+    const properties = [...(this.parentNode as Entity).properties];
+    const propertiesNameList = properties.map((item) => item.name);
+    const oldIndex = propertiesNameList.indexOf(this.name);
+    this.changeSort(properties, oldIndex, 'up');
+    this.parentNode.update({
+      properties,
+    });
+  }
+
+  /**
+   * 属性下移
+   */
+  moveDown() {
+    const properties = [...(this.parentNode as Entity).properties];
+    const propertiesNameList = properties.map((item) => item.name);
+    const oldIndex = propertiesNameList.indexOf(this.name);
+    this.changeSort(properties, oldIndex, 'down');
+    this.parentNode.update({
+      properties,
+    });
+  }
+  /**
+   * 数组移动位置
+   */
+
+  changeSort(arr: any[], index: number, type: changeType) {
+    arr.splice(type !== 'up' ? index : index - 1, 1, ...arr.splice(type !== 'up' ? index + 1 : index, 1, arr[type !== 'up' ? index : index - 1]));
+    return arr;
+  }
+
+  /**
+   * 设置关联实体属性名称
+   */
+  setRelationProperty(relationProperty: string) {
+    const object = {
+      relationProperty,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置关联实体实体名称
+   */
+  setRelationNamespace(relationNamespace: string) {
+    const object = {
+      relationNamespace,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置关联实体实体名称
+   */
+  setRelationEntity(relationEntity: string) {
+    const object = {
+      relationEntity,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置验证规则
+   */
+  setRules(rules: Array<string>) {
+    const object = {
+      rules,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 是否可编辑
+   * */
+  get readonly() {
+    return !!this.module || this.generationRule !== 'manual';
+  }
+
+  // 存储类型信息
+  get databaseTypeInfo() {
+    const dataSourceSqlType = (this.getAncestor('DataSource') as DataSource)?.dataSourceSqlType;
+    const databaseTypeMap = this.app?.__databaseTypeMap?.[dataSourceSqlType] || {};
+    const { typeKind, typeName, typeNamespace } = this?.typeAnnotation || {};
+    let databaseTypeInfo;
+    if (typeNamespace?.endsWith('.enums')) {
+      databaseTypeInfo = databaseTypeMap.enum;
+    } else {
+      databaseTypeInfo = databaseTypeMap[typeKind] || databaseTypeMap[typeName];
+    }
+    return databaseTypeInfo;
+  }
+
+  // 当前nasl类型对应的存储类型列表
+  get dataBaseTypes() {
+    return this.databaseTypeInfo?.dataBaseTypes;
+  }
+
+  // 当前nasl类型对应的存储类型Map
+  get dataBaseTypeMap() {
+    return this.databaseTypeInfo?.dataBaseTypeMap;
+  }
+
+  // 当前nasl类型对应的默认存储类型
+  get defaultDataBaseType() {
+    return this.databaseTypeInfo?.defaultDataBaseType;
+  }
+
+  // 当前选中的存储类型
+  get currentDataBaseType() {
+    if (this.databaseTypeAnnotation) {
+      const databaseTypeMap = this.dataBaseTypeMap || {};
+      const { typeName } = this.databaseTypeAnnotation;
+      return databaseTypeMap[typeName];
+    }
+    const { typeName } = this.typeAnnotation;
+    if (typeName === 'String') {
+      const defaultDataBaseName = this.inferredDefaultDataBaseName;
+      if (defaultDataBaseName && defaultDataBaseName !== this.defaultDataBaseType?.type) {
         return {
-            typeAnnotation: {
-                concept: 'TypeAnnotation',
-                typeKind: 'primitive',
-                typeNamespace: 'nasl.core',
-                typeName: 'String',
-            },
-        };
-    }
-    /**
-     * 关联属性
-     */
-    clearReference() {
-        const object = {
-            relationEntity: null as string,
-            relationProperty: null as string,
-            relationNamespace: null as string,
+          ...(this.dataBaseTypeMap[defaultDataBaseName] || {}),
         };
-        this.update({
-            ...object,
-        });
-    }
-    /**
-     * 属性上移
-     */
-    moveUp() {
-        const properties = [...(this.parentNode as Entity).properties];
-        const propertiesNameList = properties.map((item) => item.name);
-        const oldIndex = propertiesNameList.indexOf(this.name);
-        this.changeSort(properties, oldIndex, 'up');
-        this.parentNode.update({
-            properties,
-        });
-    }
-    /**
-     * 属性下移
-     */
-    moveDown() {
-        const properties = [...(this.parentNode as Entity).properties];
-        const propertiesNameList = properties.map((item) => item.name);
-        const oldIndex = propertiesNameList.indexOf(this.name);
-        this.changeSort(properties, oldIndex, 'down');
-        this.parentNode.update({
-            properties,
-        });
-    }
-    /**
-     * 数组移动位置
-     */
-
-    changeSort(arr: any[], index: number, type: changeType) {
-        arr.splice(type !== 'up' ? index : index - 1, 1, ...arr.splice(type !== 'up' ? index + 1 : index, 1, arr[type !== 'up' ? index : index - 1]));
-        return arr;
-    }
-
-    /**
-     * 设置关联实体属性名称
-     */
-    setRelationProperty(relationProperty: string) {
-        const object = {
-            relationProperty,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-     * 设置关联实体实体名称
-     */
-    setRelationNamespace(relationNamespace: string) {
-        const object = {
-            relationNamespace,
-        };
-        this.update({
-            ...object,
-        });
-    }
-    /**
-     * 设置关联实体实体名称
-     */
-    setRelationEntity(relationEntity: string) {
-        const object = {
-            relationEntity,
-        };
-        this.update({
-            ...object,
-        });
-    }
-    /**
-     * 设置验证规则
-     */
-    setRules(rules: Array<string>) {
-        const object = {
-            rules,
-        };
-        this.update({
-            ...object,
-        });
-    }
-    /**
-     * 是否可编辑
-     * */
-    get readonly() {
-        return !!this.module || this.generationRule !== 'manual';
-    }
-
-    // 存储类型信息
-    get databaseTypeInfo() {
-        const dataSourceSqlType = (this.getAncestor('DataSource') as DataSource)?.dataSourceSqlType;
-        const databaseTypeMap = this.app?.__databaseTypeMap?.[dataSourceSqlType] || {};
-        const { typeKind, typeName, typeNamespace } = this?.typeAnnotation || {};
-        let databaseTypeInfo;
-        if (typeNamespace?.endsWith('.enums')) {
-            databaseTypeInfo = databaseTypeMap.enum;
-        } else {
-            databaseTypeInfo = databaseTypeMap[typeKind] || databaseTypeMap[typeName];
-        }
-        return databaseTypeInfo;
-    }
-
-    // 当前nasl类型对应的存储类型列表
-    get dataBaseTypes() {
-        return this.databaseTypeInfo?.dataBaseTypes;
-    }
-
-    // 当前nasl类型对应的存储类型Map
-    get dataBaseTypeMap() {
-        return this.databaseTypeInfo?.dataBaseTypeMap;
-    }
-
-    // 当前nasl类型对应的默认存储类型
-    get defaultDataBaseType() {
-        return this.databaseTypeInfo?.defaultDataBaseType;
-    }
-
-    // 当前选中的存储类型
-    get currentDataBaseType() {
-        if (this.databaseTypeAnnotation) {
-            const databaseTypeMap = this.dataBaseTypeMap || {};
-            const typeName = this.databaseTypeAnnotation.typeName;
-            return databaseTypeMap[typeName];
-        } else {
-            const { typeName } = this.typeAnnotation;
-            if (typeName === 'String') {
-                const defaultDataBaseName = this.inferredDefaultDataBaseName;
-                if (defaultDataBaseName && defaultDataBaseName !== this.defaultDataBaseType?.type) {
-                    return {
-                        ...(this.dataBaseTypeMap[defaultDataBaseName] || {}),
-                    };
-                }
-            }
-            return this.defaultDataBaseType;
-        }
-    }
-
-    // 根据最大长度推断的默认数据库类型
-    get inferredDefaultDataBaseName() {
-        let defaultDataBaseName;
-        const { typeName } = this.typeAnnotation;
-        if (typeName === 'String') {
-            const dataSourceSqlType = (this.getAncestor('DataSource') as DataSource)?.dataSourceSqlType;
-            let maxLength: any;
-            const rules = this.rules;
-            if (Array.isArray(rules)) {
-                // 是否需要更新规则
-                rules.forEach((rule) => {
-                    const match = rule.match(/^([^()]+)\(([\d\-.]+)\)$/);
-                    if (match) {
-                        const [, key, value] = match;
-                        if (key === 'maxLength') {
-                            maxLength = value;
-                        }
-                    }
-                });
+      }
+    }
+    return this.defaultDataBaseType;
+  }
+
+  // 根据最大长度推断的默认数据库类型
+  get inferredDefaultDataBaseName() {
+    let defaultDataBaseName;
+    const { typeName } = this.typeAnnotation;
+    if (typeName === 'String') {
+      const dataSourceSqlType = (this.getAncestor('DataSource') as DataSource)?.dataSourceSqlType;
+      let maxLength: any;
+      const { rules } = this;
+      if (Array.isArray(rules)) {
+        // 是否需要更新规则
+        rules.forEach((rule) => {
+          const match = rule.match(/^([^()]+)\(([\d\-.]+)\)$/);
+          if (match) {
+            const [, key, value] = match;
+            if (key === 'maxLength') {
+              maxLength = value;
             }
-            // 不同数据库 最大长度 短、中、长 对应的默认储存类型
-            const sqlMap: any = {
-                mysql: {
-                    255: 'varchar',
-                    4000: 'text',
-                    16777215: 'mediumtext',
-                },
-                oracle: {
-                    255: 'varchar2',
-                    4000: 'clob',
-                    16777215: 'clob',
-                },
-                dameng: {
-                    255: 'varchar2',
-                    4000: 'text',
-                    16777215: 'text',
-                },
-                db2: {
-                    255: 'varchar',
-                    4000: 'clob',
-                    16777215: 'clob',
-                },
-            };
-            defaultDataBaseName = sqlMap?.[dataSourceSqlType]?.[maxLength];
-        }
-        return defaultDataBaseName;
-    }
-
-    __showAdvanced: boolean = false;
-
-    //================================================================================
-    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
-    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-    //================================================================================
+          }
+        });
+      }
+      // 不同数据库 最大长度 短、中、长 对应的默认储存类型
+      const sqlMap: any = {
+        mysql: {
+          255: 'varchar',
+          4000: 'text',
+          16777215: 'mediumtext',
+        },
+        oracle: {
+          255: 'varchar2',
+          4000: 'clob',
+          16777215: 'clob',
+        },
+        dameng: {
+          255: 'varchar2',
+          4000: 'text',
+          16777215: 'text',
+        },
+        db2: {
+          255: 'varchar',
+          4000: 'clob',
+          16777215: 'clob',
+        },
+      };
+      defaultDataBaseName = sqlMap?.[dataSourceSqlType]?.[maxLength];
+    }
+    return defaultDataBaseName;
+  }
+
+  __showAdvanced: boolean = false;
+
+  //= ===============================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //= ===============================================================================
 }
 
 classMap.EntityProperty = EntityProperty;
 export default EntityProperty;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================