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

package/src/concepts/App__.ts

@@ -34,43 +34,42 @@ interface compilerInfoMapProps {
 }
 
 type composeCacheType = {
-  [key: string]: composeCacheType,
+  [key: string]: composeCacheType;
 } & {
   nodes?: any[];
 };
 
-
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import type DataSource from './DataSource__';
-import type Structure from './Structure__';
-import type Enum from './Enum__';
-import type Logic from './Logic__';
-import type OverriddenLogic from './OverriddenLogic__';
-import type AbstractInterface from './AbstractInterface__';
-import type FrontendType from './FrontendType__';
+import DataSource from './DataSource__';
+import Structure from './Structure__';
+import Enum from './Enum__';
+import Logic from './Logic__';
+import OverriddenLogic from './OverriddenLogic__';
+import AbstractInterface from './AbstractInterface__';
+import FrontendType from './FrontendType__';
 import Backend from './Backend__';
-import type Process from './Process__';
-import type Role from './Role__';
+import Process from './Process__';
+import Role from './Role__';
 import Configuration from './Configuration__';
-import type Module from './Module__';
-import type Connector from './Connector__';
-import type Integration from './Integration__';
-import type AuthLogic from './AuthLogic__';
-import type AuthLogicForCallInterface from './AuthLogicForCallInterface__';
-import type Connection from './Connection__';
-import type TriggerLauncher from './TriggerLauncher__';
-import type MetadataType from './MetadataType__';
+import Module from './Module__';
+import Connector from './Connector__';
+import Integration from './Integration__';
+import AuthLogic from './AuthLogic__';
+import AuthLogicForCallInterface from './AuthLogicForCallInterface__';
+import Connection from './Connection__';
+import TriggerLauncher from './TriggerLauncher__';
+import MetadataType from './MetadataType__';
 
 /**
  * 应用
@@ -79,15 +78,13 @@ import type MetadataType from './MetadataType__';
 export class App extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'App';
-
-  /** 继承链 */
-  static readonly inheritanceChain: string[] = ['BaseNode'];
-
   /**
-   * 应用 Id
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
    */
-  @property()
-  id!: string;
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -95,54 +92,77 @@ export class App extends BaseNode {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'App';
+  /**
+   * 应用 Id
+   */
+  @property({
+    objectRef: '',
+  })
+  id: string = '';
 
   /**
    * IDE 版本
    */
-  @property()
-  ideVersion!: string;
+  @property({
+    objectRef: '',
+  })
+  ideVersion: string;
 
   /**
    * 应用标识
    */
-  @property()
-  name!: string;
+  @property({
+    objectRef: '',
+  })
+  name: string = '';
 
   /**
    * 应用标题
    */
-  @property()
-  title!: string;
+  @property({
+    objectRef: '',
+  })
+  title: string;
 
   /**
    * 应用图标
    */
-  @property()
-  icon!: string;
+  @property({
+    objectRef: '',
+  })
+  icon: string;
 
   /**
    * 应用描述
    */
-  @property()
-  desc!: string;
+  @property({
+    objectRef: '',
+  })
+  desc: string;
 
   /**
    * 域名
    */
-  @property()
-  dnsAddr!: string;
+  @property({
+    objectRef: '',
+  })
+  dnsAddr: string;
 
   /**
    * 是否有用户中心
    */
-  @property()
-  hasUserCenter!: boolean;
+  @property({
+    objectRef: '',
+  })
+  hasUserCenter: boolean;
 
   /**
    * 是否有权限
    */
-  @property()
-  hasAuth!: boolean;
+  @property({
+    objectRef: '',
+  })
+  hasAuth: boolean;
 
   /**
    * 数据源列表
@@ -276,7 +296,7 @@ export class App extends BaseNode {
   @property({
     objectRef: 'Integration',
   })
-  integration!: Integration;
+  integration: Integration;
 
   /**
    * 暴露接口的接口鉴权
@@ -341,17 +361,6 @@ export class App extends BaseNode {
     return super.from(source, parentNode, parentKey) as App;
   }
 
-  /**
-   * 从父级删除该节点
-   * @internal
-   */
-  _delete() {
-    let params: Params = null;
-    if (this.parentNode) {
-      params = (this.parentNode as any)?.__removeApp?.(this);
-    }
-    return params;
-  }
   /**
    * 设置集成
    */
@@ -519,7 +528,7 @@ export class App extends BaseNode {
 
   getStructureExistingNames(excludedList: Array<Structure> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.structures as Structure[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.structures as Structure[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getStructureUniqueName(name = 'Structure1') {
     return utils.unique(name, this.getStructureExistingNames(), undefined, true);
@@ -673,7 +682,7 @@ export class App extends BaseNode {
 
   getEnumExistingNames(excludedList: Array<Enum> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.enums as Enum[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.enums as Enum[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getEnumUniqueName(name = 'Enum1') {
     return utils.unique(name, this.getEnumExistingNames(), undefined, true);
@@ -827,7 +836,7 @@ export class App extends BaseNode {
 
   getLogicExistingNames(excludedList: Array<Logic> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.logics as Logic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.logics as Logic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getLogicUniqueName(name = 'logic1') {
     return utils.unique(name, this.getLogicExistingNames(), undefined, true);
@@ -979,502 +988,323 @@ export class App extends BaseNode {
     return node;
   }
 
+  getOverriddenLogicExistingNames(excludedList: Array<OverriddenLogic> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.overriddenLogics as OverriddenLogic[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
+  }
+  getOverriddenLogicUniqueName(name = 'overriddenLogic1') {
+    return utils.unique(name, this.getOverriddenLogicExistingNames(), undefined, true);
+  }
+
   /**
-   * 插入鉴权逻辑
+   * 插入覆写逻辑
    * @internal
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
+  _insertOverriddenLogicAt(name: string, index: number): OverriddenLogic;
 
   /**
-   * 插入鉴权逻辑
+   * 插入覆写逻辑
    * @internal
-   * @param authLogicOptions 鉴权逻辑参数
+   * @param overriddenLogicOptions 覆写逻辑参数
    */
-  _insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+  _insertOverriddenLogicAt(overriddenLogicOptions: Partial<OverriddenLogic>, index: number): OverriddenLogic;
 
   /**
-   * 插入鉴权逻辑
+   * 插入覆写逻辑
    * @internal
-   * @param authLogic 已有的鉴权逻辑实例
+   * @param overriddenLogic 已有的覆写逻辑实例
    */
-  _insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+  _insertOverriddenLogicAt(overriddenLogic: OverriddenLogic, index: number): OverriddenLogic;
 
-  _insertAuthLogicInAuthLogicsAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
-    const authLogicOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'authLogics' };
-    const AuthLogic = getConceptConstructor('AuthLogic');
-    let authLogic: AuthLogic;
+  _insertOverriddenLogicAt(options: string | Partial<OverriddenLogic> | OverriddenLogic, index: number) {
+    const overriddenLogicOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'overriddenLogics' };
+    const OverriddenLogic = getConceptConstructor('OverriddenLogic');
+    let overriddenLogic: OverriddenLogic;
     if (!options) {
-      authLogic = AuthLogic.from(
+      overriddenLogic = OverriddenLogic.from(
         {
-          ...authLogicOptions,
-          name: this.getAuthLogicUniqueName(),
+          ...overriddenLogicOptions,
+          name: this.getOverriddenLogicUniqueName(),
         },
         this,
-        'authLogics',
+        'overriddenLogics',
       );
     } else if (typeof options === 'string') {
-      authLogic = AuthLogic.from(
+      overriddenLogic = OverriddenLogic.from(
         {
-          ...authLogicOptions,
+          ...overriddenLogicOptions,
           name: options,
         },
         this,
-        'authLogics',
+        'overriddenLogics',
       );
-    } else if (asserts.isAuthLogic(options)) {
+    } else if (asserts.isOverriddenLogic(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      authLogic = options;
-      Object.assign(authLogic, relationOptions);
+      overriddenLogic = options;
+      Object.assign(overriddenLogic, relationOptions);
     } else {
-      authLogic = AuthLogic.from(
+      overriddenLogic = OverriddenLogic.from(
         {
-          ...authLogicOptions,
+          ...overriddenLogicOptions,
           ...options,
         },
         this,
-        'authLogics',
+        'overriddenLogics',
       );
     }
-    this.authLogics.splice(index, 0, authLogic);
-    return authLogic;
+    this.overriddenLogics.splice(index, 0, overriddenLogic);
+    return overriddenLogic;
   }
 
   /**
-   * 插入鉴权逻辑
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * 插入覆写逻辑
+   * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
    */
-  insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
+  insertOverriddenLogicAt(name: string, index: number): OverriddenLogic;
 
   /**
-   * 插入鉴权逻辑
-   * @param authLogicOptions 鉴权逻辑参数
+   * 插入覆写逻辑
+   * @param overriddenLogicOptions 覆写逻辑参数
    */
-  insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+  insertOverriddenLogicAt(overriddenLogicOptions: Partial<OverriddenLogic>, index: number): OverriddenLogic;
 
   /**
-   * 插入鉴权逻辑
-   * @param authLogic 已有的鉴权逻辑实例
+   * 插入覆写逻辑
+   * @param overriddenLogic 已有的覆写逻辑实例
    */
-  insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+  insertOverriddenLogicAt(overriddenLogic: OverriddenLogic, index: number): OverriddenLogic;
 
-  insertAuthLogicInAuthLogicsAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
-    const node = this._insertAuthLogicInAuthLogicsAt(options as any, index);
+  insertOverriddenLogicAt(options: string | Partial<OverriddenLogic> | OverriddenLogic, index: number) {
+    const node = this._insertOverriddenLogicAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'authLogics',
+      parentKey: 'overriddenLogics',
     });
     return node;
   }
 
   /**
-   * 添加鉴权逻辑
+   * 添加覆写逻辑
    * @internal
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _addAuthLogicInAuthLogics(name?: string): AuthLogic;
+  _addOverriddenLogic(name?: string): OverriddenLogic;
 
   /**
-   * 添加鉴权逻辑
+   * 添加覆写逻辑
    * @internal
-   * @param authLogicOptions 鉴权逻辑参数
+   * @param overriddenLogicOptions 覆写逻辑参数
    */
-  _addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+  _addOverriddenLogic(overriddenLogicOptions: Partial<OverriddenLogic>): OverriddenLogic;
 
   /**
-   * 添加鉴权逻辑
+   * 添加覆写逻辑
    * @internal
-   * @param authLogic 已有的鉴权逻辑实例
+   * @param overriddenLogic 已有的覆写逻辑实例
    */
-  _addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
+  _addOverriddenLogic(overriddenLogic: OverriddenLogic): OverriddenLogic;
 
-  _addAuthLogicInAuthLogics(options?: string | Partial<AuthLogic> | AuthLogic) {
-    const index = this.authLogics.length;
-    return this._insertAuthLogicInAuthLogicsAt(options as any, index);
+  _addOverriddenLogic(options?: string | Partial<OverriddenLogic> | OverriddenLogic) {
+    const index = 0;
+    return this._insertOverriddenLogicAt(options as any, index);
   }
 
   /**
-   * 添加鉴权逻辑
+   * 添加覆写逻辑
    * @internal
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
    */
-  addAuthLogicInAuthLogics(name?: string): AuthLogic;
+  addOverriddenLogic(name?: string): OverriddenLogic;
 
   /**
-   * 添加鉴权逻辑
-   * @param authLogicOptions 鉴权逻辑参数
+   * 添加覆写逻辑
+   * @param overriddenLogicOptions 覆写逻辑参数
    */
-  addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+  addOverriddenLogic(overriddenLogicOptions: Partial<OverriddenLogic>): OverriddenLogic;
 
   /**
-   * 添加鉴权逻辑
-   * @param authLogic 已有的鉴权逻辑实例
+   * 添加覆写逻辑
+   * @param overriddenLogic 已有的覆写逻辑实例
    */
-  addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
+  addOverriddenLogic(overriddenLogic: OverriddenLogic): OverriddenLogic;
 
-  addAuthLogicInAuthLogics(options?: string | Partial<AuthLogic> | AuthLogic) {
-    const node = this._addAuthLogicInAuthLogics(options as any);
-    const index = this.authLogics.indexOf(node);
+  addOverriddenLogic(options?: string | Partial<OverriddenLogic> | OverriddenLogic) {
+    const node = this._addOverriddenLogic(options as any);
+    const index = this.overriddenLogics.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'authLogics',
+      parentKey: 'overriddenLogics',
     });
     return node;
   }
 
+  getInterfaceExistingNames(excludedList: Array<AbstractInterface> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.interfaces as AbstractInterface[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
+  }
+  getInterfaceUniqueName(name = 'Interface1') {
+    return utils.unique(name, this.getInterfaceExistingNames(), undefined, true);
+  }
+
   /**
-   * 插入调用接口的鉴权逻辑
+   * 插入接口
    * @internal
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
    */
-  _insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
-    name: string,
-    index: number,
-  ): AuthLogicForCallInterface;
+  _insertInterfaceAt(name: string, index: number): AbstractInterface;
 
   /**
-   * 插入调用接口的鉴权逻辑
+   * 插入接口
    * @internal
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   * @param itfaceOptions 接口参数
    */
-  _insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-    index: number,
-  ): AuthLogicForCallInterface;
+  _insertInterfaceAt(itfaceOptions: Partial<AbstractInterface>, index: number): AbstractInterface;
 
   /**
-   * 插入调用接口的鉴权逻辑
+   * 插入接口
    * @internal
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   * @param itface 已有的接口实例
    */
-  _insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-    index: number,
-  ): AuthLogicForCallInterface;
+  _insertInterfaceAt(itface: AbstractInterface, index: number): AbstractInterface;
 
-  _insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
-    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
-    index: number,
-  ) {
-    const authLogicForCallInterfaceOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
-    const AuthLogicForCallInterface = getConceptConstructor('AuthLogicForCallInterface');
-    let authLogicForCallInterface: AuthLogicForCallInterface;
+  _insertInterfaceAt(options: string | Partial<AbstractInterface> | AbstractInterface, index: number) {
+    const itfaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+    const AbstractInterface = getConceptConstructor('AbstractInterface');
+    let itface: AbstractInterface;
     if (!options) {
-      authLogicForCallInterface = AuthLogicForCallInterface.from(
+      itface = AbstractInterface.from(
         {
-          ...authLogicForCallInterfaceOptions,
-          name: this.getAuthLogicForCallInterfaceUniqueName(),
+          ...itfaceOptions,
+          name: this.getInterfaceUniqueName(),
         },
         this,
-        'authLogicsForCallInterface',
+        'interfaces',
       );
     } else if (typeof options === 'string') {
-      authLogicForCallInterface = AuthLogicForCallInterface.from(
+      itface = AbstractInterface.from(
         {
-          ...authLogicForCallInterfaceOptions,
+          ...itfaceOptions,
           name: options,
         },
         this,
-        'authLogicsForCallInterface',
+        'interfaces',
       );
-    } else if (asserts.isAuthLogicForCallInterface(options)) {
+    } else if (asserts.isAbstractInterface(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      authLogicForCallInterface = options;
-      Object.assign(authLogicForCallInterface, relationOptions);
+      itface = options;
+      Object.assign(itface, relationOptions);
     } else {
-      authLogicForCallInterface = AuthLogicForCallInterface.from(
+      itface = AbstractInterface.from(
         {
-          ...authLogicForCallInterfaceOptions,
+          ...itfaceOptions,
           ...options,
         },
         this,
-        'authLogicsForCallInterface',
+        'interfaces',
       );
     }
-    this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
-    return authLogicForCallInterface;
+    this.interfaces.splice(index, 0, itface);
+    return itface;
   }
 
   /**
-   * 插入调用接口的鉴权逻辑
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * 插入接口
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
    */
-  insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
+  insertInterfaceAt(name: string, index: number): AbstractInterface;
 
   /**
-   * 插入调用接口的鉴权逻辑
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   * 插入接口
+   * @param itfaceOptions 接口参数
    */
-  insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-    index: number,
-  ): AuthLogicForCallInterface;
+  insertInterfaceAt(itfaceOptions: Partial<AbstractInterface>, index: number): AbstractInterface;
 
   /**
-   * 插入调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   * 插入接口
+   * @param itface 已有的接口实例
    */
-  insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-    index: number,
-  ): AuthLogicForCallInterface;
+  insertInterfaceAt(itface: AbstractInterface, index: number): AbstractInterface;
 
-  insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
-    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
-    index: number,
-  ) {
-    const node = this._insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(options as any, index);
+  insertInterfaceAt(options: string | Partial<AbstractInterface> | AbstractInterface, index: number) {
+    const node = this._insertInterfaceAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'authLogicsForCallInterface',
+      parentKey: 'interfaces',
     });
     return node;
   }
 
   /**
-   * 添加调用接口的鉴权逻辑
+   * 添加接口
    * @internal
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  _addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(name?: string): AuthLogicForCallInterface;
-
-  /**
-   * 添加调用接口的鉴权逻辑
-   * @internal
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
-   */
-  _addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-  ): AuthLogicForCallInterface;
-
-  /**
-   * 添加调用接口的鉴权逻辑
-   * @internal
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
-   */
-  _addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-  ): AuthLogicForCallInterface;
-
-  _addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
-    options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
-  ) {
-    const index = this.authLogicsForCallInterface.length;
-    return this._insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(options as any, index);
-  }
-
-  /**
-   * 添加调用接口的鉴权逻辑
-   * @internal
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(name?: string): AuthLogicForCallInterface;
-
-  /**
-   * 添加调用接口的鉴权逻辑
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
-   */
-  addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-  ): AuthLogicForCallInterface;
-
-  /**
-   * 添加调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
-   */
-  addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-  ): AuthLogicForCallInterface;
-
-  addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
-    options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
-  ) {
-    const node = this._addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(options as any);
-    const index = this.authLogicsForCallInterface.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'authLogicsForCallInterface',
-    });
-    return node;
-  }
-
-  getOverriddenLogicExistingNames(excludedList: Array<OverriddenLogic> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.overriddenLogics as OverriddenLogic[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
-  }
-  getOverriddenLogicUniqueName(name = 'overriddenLogic1') {
-    return utils.unique(name, this.getOverriddenLogicExistingNames(), undefined, true);
-  }
-
-  /**
-   * 插入覆写逻辑
-   * @internal
-   * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  _insertOverriddenLogicAt(name: string, index: number): OverriddenLogic;
-
-  /**
-   * 插入覆写逻辑
-   * @internal
-   * @param overriddenLogicOptions 覆写逻辑参数
-   */
-  _insertOverriddenLogicAt(overriddenLogicOptions: Partial<OverriddenLogic>, index: number): OverriddenLogic;
-
-  /**
-   * 插入覆写逻辑
-   * @internal
-   * @param overriddenLogic 已有的覆写逻辑实例
-   */
-  _insertOverriddenLogicAt(overriddenLogic: OverriddenLogic, index: number): OverriddenLogic;
-
-  _insertOverriddenLogicAt(options: string | Partial<OverriddenLogic> | OverriddenLogic, index: number) {
-    const overriddenLogicOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'overriddenLogics' };
-    const OverriddenLogic = getConceptConstructor('OverriddenLogic');
-    let overriddenLogic: OverriddenLogic;
-    if (!options) {
-      overriddenLogic = OverriddenLogic.from(
-        {
-          ...overriddenLogicOptions,
-          name: this.getOverriddenLogicUniqueName(),
-        },
-        this,
-        'overriddenLogics',
-      );
-    } else if (typeof options === 'string') {
-      overriddenLogic = OverriddenLogic.from(
-        {
-          ...overriddenLogicOptions,
-          name: options,
-        },
-        this,
-        'overriddenLogics',
-      );
-    } else if (asserts.isOverriddenLogic(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      overriddenLogic = options;
-      Object.assign(overriddenLogic, relationOptions);
-    } else {
-      overriddenLogic = OverriddenLogic.from(
-        {
-          ...overriddenLogicOptions,
-          ...options,
-        },
-        this,
-        'overriddenLogics',
-      );
-    }
-    this.overriddenLogics.splice(index, 0, overriddenLogic);
-    return overriddenLogic;
-  }
-
-  /**
-   * 插入覆写逻辑
-   * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  insertOverriddenLogicAt(name: string, index: number): OverriddenLogic;
-
-  /**
-   * 插入覆写逻辑
-   * @param overriddenLogicOptions 覆写逻辑参数
-   */
-  insertOverriddenLogicAt(overriddenLogicOptions: Partial<OverriddenLogic>, index: number): OverriddenLogic;
-
-  /**
-   * 插入覆写逻辑
-   * @param overriddenLogic 已有的覆写逻辑实例
-   */
-  insertOverriddenLogicAt(overriddenLogic: OverriddenLogic, index: number): OverriddenLogic;
-
-  insertOverriddenLogicAt(options: string | Partial<OverriddenLogic> | OverriddenLogic, index: number) {
-    const node = this._insertOverriddenLogicAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'overriddenLogics',
-    });
-    return node;
-  }
-
-  /**
-   * 添加覆写逻辑
-   * @internal
-   * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
    */
-  _addOverriddenLogic(name?: string): OverriddenLogic;
+  _addInterface(name?: string): AbstractInterface;
 
   /**
-   * 添加覆写逻辑
+   * 添加接口
    * @internal
-   * @param overriddenLogicOptions 覆写逻辑参数
+   * @param itfaceOptions 接口参数
    */
-  _addOverriddenLogic(overriddenLogicOptions: Partial<OverriddenLogic>): OverriddenLogic;
+  _addInterface(itfaceOptions: Partial<AbstractInterface>): AbstractInterface;
 
   /**
-   * 添加覆写逻辑
+   * 添加接口
    * @internal
-   * @param overriddenLogic 已有的覆写逻辑实例
+   * @param itface 已有的接口实例
    */
-  _addOverriddenLogic(overriddenLogic: OverriddenLogic): OverriddenLogic;
+  _addInterface(itface: AbstractInterface): AbstractInterface;
 
-  _addOverriddenLogic(options?: string | Partial<OverriddenLogic> | OverriddenLogic) {
+  _addInterface(options?: string | Partial<AbstractInterface> | AbstractInterface) {
     const index = 0;
-    return this._insertOverriddenLogicAt(options as any, index);
+    return this._insertInterfaceAt(options as any, index);
   }
 
   /**
-   * 添加覆写逻辑
+   * 添加接口
    * @internal
-   * @param name 覆写逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
    */
-  addOverriddenLogic(name?: string): OverriddenLogic;
+  addInterface(name?: string): AbstractInterface;
 
   /**
-   * 添加覆写逻辑
-   * @param overriddenLogicOptions 覆写逻辑参数
+   * 添加接口
+   * @param itfaceOptions 接口参数
    */
-  addOverriddenLogic(overriddenLogicOptions: Partial<OverriddenLogic>): OverriddenLogic;
+  addInterface(itfaceOptions: Partial<AbstractInterface>): AbstractInterface;
 
   /**
-   * 添加覆写逻辑
-   * @param overriddenLogic 已有的覆写逻辑实例
+   * 添加接口
+   * @param itface 已有的接口实例
    */
-  addOverriddenLogic(overriddenLogic: OverriddenLogic): OverriddenLogic;
+  addInterface(itface: AbstractInterface): AbstractInterface;
 
-  addOverriddenLogic(options?: string | Partial<OverriddenLogic> | OverriddenLogic) {
-    const node = this._addOverriddenLogic(options as any);
-    const index = this.overriddenLogics.indexOf(node);
+  addInterface(options?: string | Partial<AbstractInterface> | AbstractInterface) {
+    const node = this._addInterface(options as any);
+    const index = this.interfaces.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'overriddenLogics',
+      parentKey: 'interfaces',
     });
     return node;
   }
 
-  getAbstractInterfaceExistingNames(excludedList: Array<AbstractInterface> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.interfaces as AbstractInterface[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
-  }
-  getAbstractInterfaceUniqueName(name = 'Interface1') {
-    return utils.unique(name, this.getAbstractInterfaceExistingNames(), undefined, true);
-  }
-
   getFrontendTypeExistingNames(excludedList: Array<FrontendType> = []) {
     const excludedSet = new Set(excludedList);
     return ((this.frontendTypes as FrontendType[]) || [])
       .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
+      .map((item) => item.name);
   }
   getFrontendTypeUniqueName(name = 'frontendType1') {
     return utils.unique(name, this.getFrontendTypeExistingNames(), undefined, true);
@@ -1628,7 +1458,7 @@ export class App extends BaseNode {
 
   getProcessExistingNames(excludedList: Array<Process> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.processes as Process[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.processes as Process[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getProcessUniqueName(name = 'Process1') {
     return utils.unique(name, this.getProcessExistingNames(), undefined, true);
@@ -1782,7 +1612,7 @@ export class App extends BaseNode {
 
   getRoleExistingNames(excludedList: Array<Role> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.roles as Role[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.roles as Role[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getRoleUniqueName(name = 'role1') {
     return utils.unique(name, this.getRoleExistingNames(), undefined, true);
@@ -1936,7 +1766,7 @@ export class App extends BaseNode {
 
   getModuleExistingNames(excludedList: Array<Module> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.dependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.dependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getModuleUniqueName(name = 'module1') {
     return utils.unique(name, this.getModuleExistingNames(), undefined, false);
@@ -2089,1265 +1919,1276 @@ export class App extends BaseNode {
   }
 
   /**
-   * 插入连接器
+   * 插入模块
    * @internal
-   * @param name 连接器名称，如果不填会自动生成一个唯一名称
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  _insertConnectorInDependenciesAt(name: string, index: number): Connector;
+  _insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
 
   /**
-   * 插入连接器
+   * 插入模块
    * @internal
-   * @param connectorOptions 连接器参数
+   * @param moduleOptions 模块参数
    */
-  _insertConnectorInDependenciesAt(connectorOptions: Partial<Connector>, index: number): Connector;
+  _insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
 
   /**
-   * 插入连接器
+   * 插入模块
    * @internal
-   * @param connector 已有的连接器实例
+   * @param module 已有的模块实例
    */
-  _insertConnectorInDependenciesAt(connector: Connector, index: number): Connector;
+  _insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
 
-  _insertConnectorInDependenciesAt(options: string | Partial<Connector> | Connector, index: number) {
-    const connectorOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'dependencies' };
-    const Connector = getConceptConstructor('Connector');
-    let connector: Connector;
+  _insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+    const moduleOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'interfaceDependencies' };
+    const Module = getConceptConstructor('Module');
+    let module: Module;
     if (!options) {
-      connector = Connector.from(
+      module = Module.from(
         {
-          ...connectorOptions,
-          name: this.getConnectorUniqueName(),
+          ...moduleOptions,
+          name: this.getModuleUniqueName(),
         },
         this,
-        'dependencies',
+        'interfaceDependencies',
       );
     } else if (typeof options === 'string') {
-      connector = Connector.from(
+      module = Module.from(
         {
-          ...connectorOptions,
+          ...moduleOptions,
           name: options,
         },
         this,
-        'dependencies',
+        'interfaceDependencies',
       );
-    } else if (asserts.isConnector(options)) {
+    } else if (asserts.isModule(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      connector = options;
-      Object.assign(connector, relationOptions);
+      module = options;
+      Object.assign(module, relationOptions);
     } else {
-      connector = Connector.from(
+      module = Module.from(
         {
-          ...connectorOptions,
+          ...moduleOptions,
           ...options,
         },
         this,
-        'dependencies',
+        'interfaceDependencies',
       );
     }
-    this.dependencies.splice(index, 0, connector);
-    return connector;
+    this.interfaceDependencies.splice(index, 0, module);
+    return module;
   }
 
   /**
-   * 插入连接器
-   * @param name 连接器名称，如果不填会自动生成一个唯一名称
-   */
-  insertConnectorInDependenciesAt(name: string, index: number): Connector;
+   * 插入模块
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   */
+  insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
 
   /**
-   * 插入连接器
-   * @param connectorOptions 连接器参数
+   * 插入模块
+   * @param moduleOptions 模块参数
    */
-  insertConnectorInDependenciesAt(connectorOptions: Partial<Connector>, index: number): Connector;
+  insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
 
   /**
-   * 插入连接器
-   * @param connector 已有的连接器实例
+   * 插入模块
+   * @param module 已有的模块实例
    */
-  insertConnectorInDependenciesAt(connector: Connector, index: number): Connector;
+  insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
 
-  insertConnectorInDependenciesAt(options: string | Partial<Connector> | Connector, index: number) {
-    const node = this._insertConnectorInDependenciesAt(options as any, index);
+  insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+    const node = this._insertModuleInInterfaceDependenciesAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'dependencies',
+      parentKey: 'interfaceDependencies',
     });
     return node;
   }
 
   /**
-   * 添加连接器
+   * 添加模块
    * @internal
-   * @param name 连接器名称，如果不填会自动生成一个唯一名称
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  _addConnectorInDependencies(name?: string): Connector;
+  _addModuleInInterfaceDependencies(name?: string): Module;
 
   /**
-   * 添加连接器
+   * 添加模块
    * @internal
-   * @param connectorOptions 连接器参数
+   * @param moduleOptions 模块参数
    */
-  _addConnectorInDependencies(connectorOptions: Partial<Connector>): Connector;
+  _addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
 
   /**
-   * 添加连接器
+   * 添加模块
    * @internal
-   * @param connector 已有的连接器实例
+   * @param module 已有的模块实例
    */
-  _addConnectorInDependencies(connector: Connector): Connector;
+  _addModuleInInterfaceDependencies(module: Module): Module;
 
-  _addConnectorInDependencies(options?: string | Partial<Connector> | Connector) {
-    const index = this.dependencies.length;
-    return this._insertConnectorInDependenciesAt(options as any, index);
+  _addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
+    const index = this.interfaceDependencies.length;
+    return this._insertModuleInInterfaceDependenciesAt(options as any, index);
   }
 
   /**
-   * 添加连接器
+   * 添加模块
    * @internal
-   * @param name 连接器名称，如果不填会自动生成一个唯一名称
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  addConnectorInDependencies(name?: string): Connector;
+  addModuleInInterfaceDependencies(name?: string): Module;
 
   /**
-   * 添加连接器
-   * @param connectorOptions 连接器参数
+   * 添加模块
+   * @param moduleOptions 模块参数
    */
-  addConnectorInDependencies(connectorOptions: Partial<Connector>): Connector;
+  addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
 
   /**
-   * 添加连接器
-   * @param connector 已有的连接器实例
+   * 添加模块
+   * @param module 已有的模块实例
    */
-  addConnectorInDependencies(connector: Connector): Connector;
+  addModuleInInterfaceDependencies(module: Module): Module;
 
-  addConnectorInDependencies(options?: string | Partial<Connector> | Connector) {
-    const node = this._addConnectorInDependencies(options as any);
-    const index = this.dependencies.indexOf(node);
+  addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
+    const node = this._addModuleInInterfaceDependencies(options as any);
+    const index = this.interfaceDependencies.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'dependencies',
+      parentKey: 'interfaceDependencies',
     });
     return node;
   }
 
+  getConnectorExistingNames(excludedList: Array<Connector> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.dependencies as Connector[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getConnectorUniqueName(name = 'connector1') {
+    return utils.unique(name, this.getConnectorExistingNames(), undefined, false);
+  }
+
   /**
-   * 插入模块
+   * 插入连接器
    * @internal
-   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   * @param name 连接器名称，如果不填会自动生成一个唯一名称
    */
-  _insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
+  _insertConnectorAt(name: string, index: number): Connector;
 
   /**
-   * 插入模块
+   * 插入连接器
    * @internal
-   * @param moduleOptions 模块参数
+   * @param connectorOptions 连接器参数
    */
-  _insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+  _insertConnectorAt(connectorOptions: Partial<Connector>, index: number): Connector;
 
   /**
-   * 插入模块
+   * 插入连接器
    * @internal
-   * @param module 已有的模块实例
+   * @param connector 已有的连接器实例
    */
-  _insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
+  _insertConnectorAt(connector: Connector, index: number): Connector;
 
-  _insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
-    const moduleOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'interfaceDependencies' };
-    const Module = getConceptConstructor('Module');
-    let module: Module;
+  _insertConnectorAt(options: string | Partial<Connector> | Connector, index: number) {
+    const connectorOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'dependencies' };
+    const Connector = getConceptConstructor('Connector');
+    let connector: Connector;
     if (!options) {
-      module = Module.from(
+      connector = Connector.from(
         {
-          ...moduleOptions,
-          name: this.getModuleUniqueName(),
+          ...connectorOptions,
+          name: this.getConnectorUniqueName(),
         },
         this,
-        'interfaceDependencies',
+        'dependencies',
       );
     } else if (typeof options === 'string') {
-      module = Module.from(
+      connector = Connector.from(
         {
-          ...moduleOptions,
+          ...connectorOptions,
           name: options,
         },
         this,
-        'interfaceDependencies',
+        'dependencies',
       );
-    } else if (asserts.isModule(options)) {
+    } else if (asserts.isConnector(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      module = options;
-      Object.assign(module, relationOptions);
+      connector = options;
+      Object.assign(connector, relationOptions);
     } else {
-      module = Module.from(
+      connector = Connector.from(
         {
-          ...moduleOptions,
+          ...connectorOptions,
           ...options,
         },
         this,
-        'interfaceDependencies',
+        'dependencies',
       );
     }
-    this.interfaceDependencies.splice(index, 0, module);
-    return module;
+    this.dependencies.splice(index, 0, connector);
+    return connector;
   }
 
   /**
-   * 插入模块
-   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   * 插入连接器
+   * @param name 连接器名称，如果不填会自动生成一个唯一名称
    */
-  insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
+  insertConnectorAt(name: string, index: number): Connector;
 
   /**
-   * 插入模块
-   * @param moduleOptions 模块参数
+   * 插入连接器
+   * @param connectorOptions 连接器参数
    */
-  insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+  insertConnectorAt(connectorOptions: Partial<Connector>, index: number): Connector;
 
   /**
-   * 插入模块
-   * @param module 已有的模块实例
+   * 插入连接器
+   * @param connector 已有的连接器实例
    */
-  insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
+  insertConnectorAt(connector: Connector, index: number): Connector;
 
-  insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
-    const node = this._insertModuleInInterfaceDependenciesAt(options as any, index);
+  insertConnectorAt(options: string | Partial<Connector> | Connector, index: number) {
+    const node = this._insertConnectorAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'interfaceDependencies',
+      parentKey: 'dependencies',
     });
     return node;
   }
 
   /**
-   * 添加模块
+   * 添加连接器
    * @internal
-   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   * @param name 连接器名称，如果不填会自动生成一个唯一名称
    */
-  _addModuleInInterfaceDependencies(name?: string): Module;
+  _addConnector(name?: string): Connector;
 
   /**
-   * 添加模块
+   * 添加连接器
    * @internal
-   * @param moduleOptions 模块参数
+   * @param connectorOptions 连接器参数
    */
-  _addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
+  _addConnector(connectorOptions: Partial<Connector>): Connector;
 
   /**
-   * 添加模块
+   * 添加连接器
    * @internal
-   * @param module 已有的模块实例
+   * @param connector 已有的连接器实例
    */
-  _addModuleInInterfaceDependencies(module: Module): Module;
+  _addConnector(connector: Connector): Connector;
 
-  _addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
-    const index = this.interfaceDependencies.length;
-    return this._insertModuleInInterfaceDependenciesAt(options as any, index);
+  _addConnector(options?: string | Partial<Connector> | Connector) {
+    const index = this.dependencies.length;
+    return this._insertConnectorAt(options as any, index);
   }
 
   /**
-   * 添加模块
+   * 添加连接器
    * @internal
-   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   * @param name 连接器名称，如果不填会自动生成一个唯一名称
    */
-  addModuleInInterfaceDependencies(name?: string): Module;
+  addConnector(name?: string): Connector;
 
   /**
-   * 添加模块
-   * @param moduleOptions 模块参数
+   * 添加连接器
+   * @param connectorOptions 连接器参数
    */
-  addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
+  addConnector(connectorOptions: Partial<Connector>): Connector;
 
   /**
-   * 添加模块
-   * @param module 已有的模块实例
+   * 添加连接器
+   * @param connector 已有的连接器实例
    */
-  addModuleInInterfaceDependencies(module: Module): Module;
+  addConnector(connector: Connector): Connector;
 
-  addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
-    const node = this._addModuleInInterfaceDependencies(options as any);
-    const index = this.interfaceDependencies.indexOf(node);
+  addConnector(options?: string | Partial<Connector> | Connector) {
+    const node = this._addConnector(options as any);
+    const index = this.dependencies.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'interfaceDependencies',
+      parentKey: 'dependencies',
     });
     return node;
   }
 
-  getConnectionExistingNames(excludedList: Array<Connection> = []) {
+  getAuthLogicExistingNames(excludedList: Array<AuthLogic> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.connections as Connection[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
+    return ((this.authLogics as AuthLogic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-  getConnectionUniqueName(name = 'connection1') {
-    return utils.unique(name, this.getConnectionExistingNames(), undefined, false);
+  getAuthLogicUniqueName(name = 'authentication1') {
+    return utils.unique(name, this.getAuthLogicExistingNames(), undefined, false);
   }
 
   /**
-   * 插入连接
+   * 插入鉴权逻辑
    * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _insertConnectionAt(name: string, index: number): Connection;
+  _insertAuthLogicAt(name: string, index: number): AuthLogic;
 
   /**
-   * 插入连接
+   * 插入鉴权逻辑
    * @internal
-   * @param connectionOptions 连接参数
+   * @param authLogicOptions 鉴权逻辑参数
    */
-  _insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+  _insertAuthLogicAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
 
   /**
-   * 插入连接
+   * 插入鉴权逻辑
    * @internal
-   * @param connection 已有的连接实例
+   * @param authLogic 已有的鉴权逻辑实例
    */
-  _insertConnectionAt(connection: Connection, index: number): Connection;
+  _insertAuthLogicAt(authLogic: AuthLogic, index: number): AuthLogic;
 
-  _insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
-    const connectionOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'connections' };
-    const Connection = getConceptConstructor('Connection');
-    let connection: Connection;
+  _insertAuthLogicAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
+    const authLogicOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'authLogics' };
+    const AuthLogic = getConceptConstructor('AuthLogic');
+    let authLogic: AuthLogic;
     if (!options) {
-      connection = Connection.from(
+      authLogic = AuthLogic.from(
         {
-          ...connectionOptions,
-          name: this.getConnectionUniqueName(),
+          ...authLogicOptions,
+          name: this.getAuthLogicUniqueName(),
         },
         this,
-        'connections',
+        'authLogics',
       );
     } else if (typeof options === 'string') {
-      connection = Connection.from(
+      authLogic = AuthLogic.from(
         {
-          ...connectionOptions,
+          ...authLogicOptions,
           name: options,
         },
         this,
-        'connections',
+        'authLogics',
       );
-    } else if (asserts.isConnection(options)) {
+    } else if (asserts.isAuthLogic(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      connection = options;
-      Object.assign(connection, relationOptions);
+      authLogic = options;
+      Object.assign(authLogic, relationOptions);
     } else {
-      connection = Connection.from(
+      authLogic = AuthLogic.from(
         {
-          ...connectionOptions,
+          ...authLogicOptions,
           ...options,
         },
         this,
-        'connections',
+        'authLogics',
       );
     }
-    this.connections.splice(index, 0, connection);
-    return connection;
+    this.authLogics.splice(index, 0, authLogic);
+    return authLogic;
   }
 
   /**
-   * 插入连接
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   * 插入鉴权逻辑
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  insertConnectionAt(name: string, index: number): Connection;
+  insertAuthLogicAt(name: string, index: number): AuthLogic;
 
   /**
-   * 插入连接
-   * @param connectionOptions 连接参数
+   * 插入鉴权逻辑
+   * @param authLogicOptions 鉴权逻辑参数
    */
-  insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+  insertAuthLogicAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
 
   /**
-   * 插入连接
-   * @param connection 已有的连接实例
+   * 插入鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
    */
-  insertConnectionAt(connection: Connection, index: number): Connection;
+  insertAuthLogicAt(authLogic: AuthLogic, index: number): AuthLogic;
 
-  insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
-    const node = this._insertConnectionAt(options as any, index);
+  insertAuthLogicAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
+    const node = this._insertAuthLogicAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'connections',
+      parentKey: 'authLogics',
     });
     return node;
   }
 
   /**
-   * 添加连接
+   * 添加鉴权逻辑
    * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _addConnection(name?: string): Connection;
+  _addAuthLogic(name?: string): AuthLogic;
 
   /**
-   * 添加连接
+   * 添加鉴权逻辑
    * @internal
-   * @param connectionOptions 连接参数
+   * @param authLogicOptions 鉴权逻辑参数
    */
-  _addConnection(connectionOptions: Partial<Connection>): Connection;
+  _addAuthLogic(authLogicOptions: Partial<AuthLogic>): AuthLogic;
 
   /**
-   * 添加连接
+   * 添加鉴权逻辑
    * @internal
-   * @param connection 已有的连接实例
+   * @param authLogic 已有的鉴权逻辑实例
    */
-  _addConnection(connection: Connection): Connection;
+  _addAuthLogic(authLogic: AuthLogic): AuthLogic;
 
-  _addConnection(options?: string | Partial<Connection> | Connection) {
-    const index = this.connections.length;
-    return this._insertConnectionAt(options as any, index);
+  _addAuthLogic(options?: string | Partial<AuthLogic> | AuthLogic) {
+    const index = this.authLogics.length;
+    return this._insertAuthLogicAt(options as any, index);
   }
 
   /**
-   * 添加连接
+   * 添加鉴权逻辑
    * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  addConnection(name?: string): Connection;
+  addAuthLogic(name?: string): AuthLogic;
 
   /**
-   * 添加连接
-   * @param connectionOptions 连接参数
+   * 添加鉴权逻辑
+   * @param authLogicOptions 鉴权逻辑参数
    */
-  addConnection(connectionOptions: Partial<Connection>): Connection;
+  addAuthLogic(authLogicOptions: Partial<AuthLogic>): AuthLogic;
 
   /**
-   * 添加连接
-   * @param connection 已有的连接实例
+   * 添加鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
    */
-  addConnection(connection: Connection): Connection;
+  addAuthLogic(authLogic: AuthLogic): AuthLogic;
 
-  addConnection(options?: string | Partial<Connection> | Connection) {
-    const node = this._addConnection(options as any);
-    const index = this.connections.indexOf(node);
+  addAuthLogic(options?: string | Partial<AuthLogic> | AuthLogic) {
+    const node = this._addAuthLogic(options as any);
+    const index = this.authLogics.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'connections',
+      parentKey: 'authLogics',
     });
     return node;
   }
 
-  getTriggerLauncherExistingNames(excludedList: Array<TriggerLauncher> = []) {
+  getAuthLogicForCallInterfaceExistingNames(excludedList: Array<AuthLogicForCallInterface> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.triggerLaunchers as TriggerLauncher[]) || [])
+    return ((this.authLogicsForCallInterface as AuthLogicForCallInterface[]) || [])
       .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
+      .map((item) => item.name);
   }
-  getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
-    return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
+  getAuthLogicForCallInterfaceUniqueName(name = 'authLogicForCallInterface1') {
+    return utils.unique(name, this.getAuthLogicForCallInterfaceExistingNames(), undefined, false);
   }
 
   /**
-   * 插入触发器启动器
+   * 插入调用接口的鉴权逻辑
    * @internal
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
+  _insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
 
   /**
-   * 插入触发器启动器
+   * 插入调用接口的鉴权逻辑
    * @internal
-   * @param triggerLauncherOptions 触发器启动器参数
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
    */
-  _insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
+  _insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+    index: number,
+  ): AuthLogicForCallInterface;
 
   /**
-   * 插入触发器启动器
+   * 插入调用接口的鉴权逻辑
    * @internal
-   * @param triggerLauncher 已有的触发器启动器实例
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  _insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
+  _insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+    index: number,
+  ): AuthLogicForCallInterface;
 
-  _insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
-    const triggerLauncherOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
-    const TriggerLauncher = getConceptConstructor('TriggerLauncher');
-    let triggerLauncher: TriggerLauncher;
+  _insertAuthLogicForCallInterfaceAt(
+    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+    index: number,
+  ) {
+    const authLogicForCallInterfaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
+    const AuthLogicForCallInterface = getConceptConstructor('AuthLogicForCallInterface');
+    let authLogicForCallInterface: AuthLogicForCallInterface;
     if (!options) {
-      triggerLauncher = TriggerLauncher.from(
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
         {
-          ...triggerLauncherOptions,
-          name: this.getTriggerLauncherUniqueName(),
+          ...authLogicForCallInterfaceOptions,
+          name: this.getAuthLogicForCallInterfaceUniqueName(),
         },
         this,
-        'triggerLaunchers',
+        'authLogicsForCallInterface',
       );
     } else if (typeof options === 'string') {
-      triggerLauncher = TriggerLauncher.from(
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
         {
-          ...triggerLauncherOptions,
+          ...authLogicForCallInterfaceOptions,
           name: options,
         },
         this,
-        'triggerLaunchers',
+        'authLogicsForCallInterface',
       );
-    } else if (asserts.isTriggerLauncher(options)) {
+    } else if (asserts.isAuthLogicForCallInterface(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      triggerLauncher = options;
-      Object.assign(triggerLauncher, relationOptions);
+      authLogicForCallInterface = options;
+      Object.assign(authLogicForCallInterface, relationOptions);
     } else {
-      triggerLauncher = TriggerLauncher.from(
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
         {
-          ...triggerLauncherOptions,
+          ...authLogicForCallInterfaceOptions,
           ...options,
         },
         this,
-        'triggerLaunchers',
+        'authLogicsForCallInterface',
       );
     }
-    this.triggerLaunchers.splice(index, 0, triggerLauncher);
-    return triggerLauncher;
+    this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
+    return authLogicForCallInterface;
   }
 
   /**
-   * 插入触发器启动器
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   * 插入调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
+  insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
 
   /**
-   * 插入触发器启动器
-   * @param triggerLauncherOptions 触发器启动器参数
+   * 插入调用接口的鉴权逻辑
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
    */
-  insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
+  insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+    index: number,
+  ): AuthLogicForCallInterface;
 
   /**
-   * 插入触发器启动器
-   * @param triggerLauncher 已有的触发器启动器实例
+   * 插入调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
+  insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+    index: number,
+  ): AuthLogicForCallInterface;
 
-  insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
-    const node = this._insertTriggerLauncherAt(options as any, index);
+  insertAuthLogicForCallInterfaceAt(
+    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+    index: number,
+  ) {
+    const node = this._insertAuthLogicForCallInterfaceAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'triggerLaunchers',
+      parentKey: 'authLogicsForCallInterface',
     });
     return node;
   }
 
   /**
-   * 添加触发器启动器
+   * 添加调用接口的鉴权逻辑
    * @internal
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _addTriggerLauncher(name?: string): TriggerLauncher;
+  _addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
 
   /**
-   * 添加触发器启动器
+   * 添加调用接口的鉴权逻辑
    * @internal
-   * @param triggerLauncherOptions 触发器启动器参数
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
    */
-  _addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
+  _addAuthLogicForCallInterface(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+  ): AuthLogicForCallInterface;
 
   /**
-   * 添加触发器启动器
+   * 添加调用接口的鉴权逻辑
    * @internal
-   * @param triggerLauncher 已有的触发器启动器实例
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  _addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
+  _addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
 
-  _addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
-    const index = this.triggerLaunchers.length;
-    return this._insertTriggerLauncherAt(options as any, index);
+  _addAuthLogicForCallInterface(options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface) {
+    const index = this.authLogicsForCallInterface.length;
+    return this._insertAuthLogicForCallInterfaceAt(options as any, index);
   }
 
   /**
-   * 添加触发器启动器
+   * 添加调用接口的鉴权逻辑
    * @internal
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  addTriggerLauncher(name?: string): TriggerLauncher;
+  addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
 
   /**
-   * 添加触发器启动器
-   * @param triggerLauncherOptions 触发器启动器参数
+   * 添加调用接口的鉴权逻辑
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
    */
-  addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
+  addAuthLogicForCallInterface(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+  ): AuthLogicForCallInterface;
 
   /**
-   * 添加触发器启动器
-   * @param triggerLauncher 已有的触发器启动器实例
+   * 添加调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
+  addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
 
-  addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
-    const node = this._addTriggerLauncher(options as any);
-    const index = this.triggerLaunchers.indexOf(node);
+  addAuthLogicForCallInterface(options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface) {
+    const node = this._addAuthLogicForCallInterface(options as any);
+    const index = this.authLogicsForCallInterface.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'triggerLaunchers',
+      parentKey: 'authLogicsForCallInterface',
     });
     return node;
   }
 
-  getMetadataTypeExistingNames(excludedList: Array<MetadataType> = []) {
+  getConnectionExistingNames(excludedList: Array<Connection> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.metadataTypes as MetadataType[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
+    return ((this.connections as Connection[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-  getMetadataTypeUniqueName(name = 'MetadataType1') {
-    return utils.unique(name, this.getMetadataTypeExistingNames(), undefined, true);
+  getConnectionUniqueName(name = 'connection1') {
+    return utils.unique(name, this.getConnectionExistingNames(), undefined, false);
   }
 
   /**
-   * 插入元数据类型
+   * 插入连接
    * @internal
-   * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
    */
-  _insertMetadataTypeAt(name: string, index: number): MetadataType;
+  _insertConnectionAt(name: string, index: number): Connection;
 
   /**
-   * 插入元数据类型
+   * 插入连接
    * @internal
-   * @param metadataTypeOptions 元数据类型参数
+   * @param connectionOptions 连接参数
    */
-  _insertMetadataTypeAt(metadataTypeOptions: Partial<MetadataType>, index: number): MetadataType;
+  _insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
 
   /**
-   * 插入元数据类型
+   * 插入连接
    * @internal
-   * @param metadataType 已有的元数据类型实例
+   * @param connection 已有的连接实例
    */
-  _insertMetadataTypeAt(metadataType: MetadataType, index: number): MetadataType;
+  _insertConnectionAt(connection: Connection, index: number): Connection;
 
-  _insertMetadataTypeAt(options: string | Partial<MetadataType> | MetadataType, index: number) {
-    const metadataTypeOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'metadataTypes' };
-    const MetadataType = getConceptConstructor('MetadataType');
-    let metadataType: MetadataType;
+  _insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
+    const connectionOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'connections' };
+    const Connection = getConceptConstructor('Connection');
+    let connection: Connection;
     if (!options) {
-      metadataType = MetadataType.from(
+      connection = Connection.from(
         {
-          ...metadataTypeOptions,
-          name: this.getMetadataTypeUniqueName(),
+          ...connectionOptions,
+          name: this.getConnectionUniqueName(),
         },
         this,
-        'metadataTypes',
+        'connections',
       );
     } else if (typeof options === 'string') {
-      metadataType = MetadataType.from(
+      connection = Connection.from(
         {
-          ...metadataTypeOptions,
+          ...connectionOptions,
           name: options,
         },
         this,
-        'metadataTypes',
+        'connections',
       );
-    } else if (asserts.isMetadataType(options)) {
+    } else if (asserts.isConnection(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      metadataType = options;
-      Object.assign(metadataType, relationOptions);
+      connection = options;
+      Object.assign(connection, relationOptions);
     } else {
-      metadataType = MetadataType.from(
+      connection = Connection.from(
         {
-          ...metadataTypeOptions,
+          ...connectionOptions,
           ...options,
         },
         this,
-        'metadataTypes',
+        'connections',
       );
     }
-    this.metadataTypes.splice(index, 0, metadataType);
-    return metadataType;
+    this.connections.splice(index, 0, connection);
+    return connection;
   }
 
   /**
-   * 插入元数据类型
-   * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
+   * 插入连接
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
    */
-  insertMetadataTypeAt(name: string, index: number): MetadataType;
+  insertConnectionAt(name: string, index: number): Connection;
 
   /**
-   * 插入元数据类型
-   * @param metadataTypeOptions 元数据类型参数
+   * 插入连接
+   * @param connectionOptions 连接参数
    */
-  insertMetadataTypeAt(metadataTypeOptions: Partial<MetadataType>, index: number): MetadataType;
+  insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
 
   /**
-   * 插入元数据类型
-   * @param metadataType 已有的元数据类型实例
+   * 插入连接
+   * @param connection 已有的连接实例
    */
-  insertMetadataTypeAt(metadataType: MetadataType, index: number): MetadataType;
+  insertConnectionAt(connection: Connection, index: number): Connection;
 
-  insertMetadataTypeAt(options: string | Partial<MetadataType> | MetadataType, index: number) {
-    const node = this._insertMetadataTypeAt(options as any, index);
+  insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
+    const node = this._insertConnectionAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'metadataTypes',
+      parentKey: 'connections',
     });
     return node;
   }
 
   /**
-   * 添加元数据类型
+   * 添加连接
    * @internal
-   * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
    */
-  _addMetadataType(name?: string): MetadataType;
+  _addConnection(name?: string): Connection;
 
   /**
-   * 添加元数据类型
+   * 添加连接
    * @internal
-   * @param metadataTypeOptions 元数据类型参数
+   * @param connectionOptions 连接参数
    */
-  _addMetadataType(metadataTypeOptions: Partial<MetadataType>): MetadataType;
+  _addConnection(connectionOptions: Partial<Connection>): Connection;
 
   /**
-   * 添加元数据类型
+   * 添加连接
    * @internal
-   * @param metadataType 已有的元数据类型实例
+   * @param connection 已有的连接实例
    */
-  _addMetadataType(metadataType: MetadataType): MetadataType;
+  _addConnection(connection: Connection): Connection;
 
-  _addMetadataType(options?: string | Partial<MetadataType> | MetadataType) {
-    const index = 0;
-    return this._insertMetadataTypeAt(options as any, index);
+  _addConnection(options?: string | Partial<Connection> | Connection) {
+    const index = this.connections.length;
+    return this._insertConnectionAt(options as any, index);
   }
 
   /**
-   * 添加元数据类型
+   * 添加连接
    * @internal
-   * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
    */
-  addMetadataType(name?: string): MetadataType;
+  addConnection(name?: string): Connection;
 
   /**
-   * 添加元数据类型
-   * @param metadataTypeOptions 元数据类型参数
+   * 添加连接
+   * @param connectionOptions 连接参数
    */
-  addMetadataType(metadataTypeOptions: Partial<MetadataType>): MetadataType;
+  addConnection(connectionOptions: Partial<Connection>): Connection;
 
   /**
-   * 添加元数据类型
-   * @param metadataType 已有的元数据类型实例
+   * 添加连接
+   * @param connection 已有的连接实例
    */
-  addMetadataType(metadataType: MetadataType): MetadataType;
+  addConnection(connection: Connection): Connection;
 
-  addMetadataType(options?: string | Partial<MetadataType> | MetadataType) {
-    const node = this._addMetadataType(options as any);
-    const index = this.metadataTypes.indexOf(node);
+  addConnection(options?: string | Partial<Connection> | Connection) {
+    const node = this._addConnection(options as any);
+    const index = this.connections.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'metadataTypes',
+      parentKey: 'connections',
     });
     return node;
   }
 
+  getTriggerLauncherExistingNames(excludedList: Array<TriggerLauncher> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.triggerLaunchers as TriggerLauncher[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
+  }
+  getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
+    return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
+  }
+
   /**
-   * 删除数据源
-   * @param name 数据源名称
+   * 插入触发器启动器
+   * @internal
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
    */
-  removeDataSource(name: string): void;
+  _insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
 
   /**
-   * 删除数据源
-   * @param dataSource 已有的数据源实例
+   * 插入触发器启动器
+   * @internal
+   * @param triggerLauncherOptions 触发器启动器参数
    */
-  removeDataSource(dataSource: DataSource): void;
+  _insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
 
-  removeDataSource(options: string | DataSource) {
-    let dataSource: DataSource;
-    if (typeof options === 'string') {
-      dataSource = (this.dataSources as DataSource[]).find((item) => item.name === options);
-      if (!dataSource) {
-        throw new Error('找不到数据源 ' + options);
-      }
-    } else {
-      dataSource = options;
-    }
-    return dataSource.delete();
-  }
+  /**
+   * 插入触发器启动器
+   * @internal
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  _insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
 
-  __removeDataSource(dataSource: DataSource) {
-    const parentKey = dataSource.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: dataSource,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = dataSource.__v_raw || dataSource;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
+  _insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
+    const triggerLauncherOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
+    const TriggerLauncher = getConceptConstructor('TriggerLauncher');
+    let triggerLauncher: TriggerLauncher;
+    if (!options) {
+      triggerLauncher = TriggerLauncher.from(
+        {
+          ...triggerLauncherOptions,
+          name: this.getTriggerLauncherUniqueName(),
+        },
+        this,
+        'triggerLaunchers',
+      );
+    } else if (typeof options === 'string') {
+      triggerLauncher = TriggerLauncher.from(
+        {
+          ...triggerLauncherOptions,
+          name: options,
+        },
+        this,
+        'triggerLaunchers',
+      );
+    } else if (asserts.isTriggerLauncher(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      triggerLauncher = options;
+      Object.assign(triggerLauncher, relationOptions);
+    } else {
+      triggerLauncher = TriggerLauncher.from(
+        {
+          ...triggerLauncherOptions,
+          ...options,
+        },
+        this,
+        'triggerLaunchers',
+      );
     }
-    return params;
+    this.triggerLaunchers.splice(index, 0, triggerLauncher);
+    return triggerLauncher;
   }
 
   /**
-   * 删除数据结构
-   * @param name 数据结构名称
+   * 插入触发器启动器
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
    */
-  removeStructure(name: string): void;
+  insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
 
   /**
-   * 删除数据结构
-   * @param structure 已有的数据结构实例
+   * 插入触发器启动器
+   * @param triggerLauncherOptions 触发器启动器参数
    */
-  removeStructure(structure: Structure): void;
+  insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
 
-  removeStructure(options: string | Structure) {
-    let structure: Structure;
-    if (typeof options === 'string') {
-      structure = (this.structures as Structure[]).find((item) => item.name === options);
-      if (!structure) {
-        throw new Error('找不到数据结构 ' + options);
-      }
-    } else {
-      structure = options;
-    }
-    return structure.delete();
-  }
+  /**
+   * 插入触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
 
-  __removeStructure(structure: Structure) {
-    const parentKey = structure.parentKey;
-    const params: Params = {
+  insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
+    const node = this._insertTriggerLauncherAt(options as any, index);
+    node.create({
+      index,
       parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: structure,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = structure.__v_raw || structure;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
+      parentKey: 'triggerLaunchers',
+    });
+    return node;
   }
 
   /**
-   * 删除枚举
-   * @param name 枚举名称
+   * 添加触发器启动器
+   * @internal
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
    */
-  removeEnum(name: string): void;
+  _addTriggerLauncher(name?: string): TriggerLauncher;
 
   /**
-   * 删除枚举
-   * @param enumeration 已有的枚举实例
+   * 添加触发器启动器
+   * @internal
+   * @param triggerLauncherOptions 触发器启动器参数
    */
-  removeEnum(enumeration: Enum): void;
+  _addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
 
-  removeEnum(options: string | Enum) {
-    let enumeration: Enum;
-    if (typeof options === 'string') {
-      enumeration = (this.enums as Enum[]).find((item) => item.name === options);
-      if (!enumeration) {
-        throw new Error('找不到枚举 ' + options);
-      }
-    } else {
-      enumeration = options;
-    }
-    return enumeration.delete();
-  }
+  /**
+   * 添加触发器启动器
+   * @internal
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  _addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
 
-  __removeEnum(enumeration: Enum) {
-    const parentKey = enumeration.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: enumeration,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = enumeration.__v_raw || enumeration;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
+  _addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
+    const index = this.triggerLaunchers.length;
+    return this._insertTriggerLauncherAt(options as any, index);
   }
 
   /**
-   * 删除逻辑
-   * @param name 逻辑名称
+   * 添加触发器启动器
+   * @internal
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
    */
-  removeLogic(name: string): void;
+  addTriggerLauncher(name?: string): TriggerLauncher;
 
   /**
-   * 删除逻辑
-   * @param logic 已有的逻辑实例
+   * 添加触发器启动器
+   * @param triggerLauncherOptions 触发器启动器参数
    */
-  removeLogic(logic: Logic): void;
+  addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
 
-  removeLogic(options: string | Logic) {
-    let logic: Logic;
-    if (typeof options === 'string') {
-      logic = (this.logics as Logic[]).find((item) => item.name === options);
-      if (!logic) {
-        throw new Error('找不到逻辑 ' + options);
-      }
-    } else {
-      logic = options;
-    }
-    return logic.delete();
+  /**
+   * 添加触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
+
+  addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
+    const node = this._addTriggerLauncher(options as any);
+    const index = this.triggerLaunchers.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'triggerLaunchers',
+    });
+    return node;
+  }
+
+  getMetadataTypeExistingNames(excludedList: Array<MetadataType> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.metadataTypes as MetadataType[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
+  }
+  getMetadataTypeUniqueName(name = 'MetadataType1') {
+    return utils.unique(name, this.getMetadataTypeExistingNames(), undefined, true);
   }
 
   /**
-   * 删除鉴权逻辑
-   * @param name 鉴权逻辑名称
+   * 插入元数据类型
+   * @internal
+   * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
    */
-  removeAuthLogicInAuthLogics(name: string): void;
+  _insertMetadataTypeAt(name: string, index: number): MetadataType;
 
   /**
-   * 删除鉴权逻辑
-   * @param authLogic 已有的鉴权逻辑实例
+   * 插入元数据类型
+   * @internal
+   * @param metadataTypeOptions 元数据类型参数
    */
-  removeAuthLogicInAuthLogics(authLogic: AuthLogic): void;
+  _insertMetadataTypeAt(metadataTypeOptions: Partial<MetadataType>, index: number): MetadataType;
 
-  removeAuthLogicInAuthLogics(options: string | AuthLogic) {
-    let authLogic: AuthLogic;
-    if (typeof options === 'string') {
-      authLogic = (this.authLogics as AuthLogic[]).find((item) => item.name === options);
-      if (!authLogic) {
-        throw new Error('找不到鉴权逻辑 ' + options);
-      }
+  /**
+   * 插入元数据类型
+   * @internal
+   * @param metadataType 已有的元数据类型实例
+   */
+  _insertMetadataTypeAt(metadataType: MetadataType, index: number): MetadataType;
+
+  _insertMetadataTypeAt(options: string | Partial<MetadataType> | MetadataType, index: number) {
+    const metadataTypeOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'metadataTypes' };
+    const MetadataType = getConceptConstructor('MetadataType');
+    let metadataType: MetadataType;
+    if (!options) {
+      metadataType = MetadataType.from(
+        {
+          ...metadataTypeOptions,
+          name: this.getMetadataTypeUniqueName(),
+        },
+        this,
+        'metadataTypes',
+      );
+    } else if (typeof options === 'string') {
+      metadataType = MetadataType.from(
+        {
+          ...metadataTypeOptions,
+          name: options,
+        },
+        this,
+        'metadataTypes',
+      );
+    } else if (asserts.isMetadataType(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      metadataType = options;
+      Object.assign(metadataType, relationOptions);
     } else {
-      authLogic = options;
+      metadataType = MetadataType.from(
+        {
+          ...metadataTypeOptions,
+          ...options,
+        },
+        this,
+        'metadataTypes',
+      );
     }
-    return authLogic.delete();
+    this.metadataTypes.splice(index, 0, metadataType);
+    return metadataType;
   }
 
   /**
-   * 删除调用接口的鉴权逻辑
-   * @param name 调用接口的鉴权逻辑名称
+   * 插入元数据类型
+   * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
    */
-  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(name: string): void;
+  insertMetadataTypeAt(name: string, index: number): MetadataType;
 
   /**
-   * 删除调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   * 插入元数据类型
+   * @param metadataTypeOptions 元数据类型参数
    */
-  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-  ): void;
+  insertMetadataTypeAt(metadataTypeOptions: Partial<MetadataType>, index: number): MetadataType;
 
-  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(options: string | AuthLogicForCallInterface) {
-    let authLogicForCallInterface: AuthLogicForCallInterface;
-    if (typeof options === 'string') {
-      authLogicForCallInterface = (this.authLogicsForCallInterface as AuthLogicForCallInterface[]).find(
-        (item) => item.name === options,
-      );
-      if (!authLogicForCallInterface) {
-        throw new Error('找不到调用接口的鉴权逻辑 ' + options);
-      }
-    } else {
-      authLogicForCallInterface = options;
-    }
-    return authLogicForCallInterface.delete();
-  }
+  /**
+   * 插入元数据类型
+   * @param metadataType 已有的元数据类型实例
+   */
+  insertMetadataTypeAt(metadataType: MetadataType, index: number): MetadataType;
 
-  __removeLogic(logic: Logic) {
-    const parentKey = logic.parentKey;
-    const params: Params = {
+  insertMetadataTypeAt(options: string | Partial<MetadataType> | MetadataType, index: number) {
+    const node = this._insertMetadataTypeAt(options as any, index);
+    node.create({
+      index,
       parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logic,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logic.__v_raw || logic;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
+      parentKey: 'metadataTypes',
+    });
+    return node;
   }
 
   /**
-   * 删除覆写逻辑
-   * @param name 覆写逻辑名称
+   * 添加元数据类型
+   * @internal
+   * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
    */
-  removeOverriddenLogic(name: string): void;
+  _addMetadataType(name?: string): MetadataType;
 
   /**
-   * 删除覆写逻辑
-   * @param overriddenLogic 已有的覆写逻辑实例
+   * 添加元数据类型
+   * @internal
+   * @param metadataTypeOptions 元数据类型参数
    */
-  removeOverriddenLogic(overriddenLogic: OverriddenLogic): void;
+  _addMetadataType(metadataTypeOptions: Partial<MetadataType>): MetadataType;
 
-  removeOverriddenLogic(options: string | OverriddenLogic) {
-    let overriddenLogic: OverriddenLogic;
-    if (typeof options === 'string') {
-      overriddenLogic = (this.overriddenLogics as OverriddenLogic[]).find((item) => item.name === options);
-      if (!overriddenLogic) {
-        throw new Error('找不到覆写逻辑 ' + options);
-      }
-    } else {
-      overriddenLogic = options;
-    }
-    return overriddenLogic.delete();
-  }
+  /**
+   * 添加元数据类型
+   * @internal
+   * @param metadataType 已有的元数据类型实例
+   */
+  _addMetadataType(metadataType: MetadataType): MetadataType;
 
-  __removeOverriddenLogic(overriddenLogic: OverriddenLogic) {
-    const parentKey = overriddenLogic.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: overriddenLogic,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = overriddenLogic.__v_raw || overriddenLogic;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
+  _addMetadataType(options?: string | Partial<MetadataType> | MetadataType) {
+    const index = 0;
+    return this._insertMetadataTypeAt(options as any, index);
   }
 
   /**
-   * 删除接口
-   * @param name 接口名称
+   * 添加元数据类型
+   * @internal
+   * @param name 元数据类型名称，如果不填会自动生成一个唯一名称
    */
-  removeAbstractInterface(name: string): void;
+  addMetadataType(name?: string): MetadataType;
 
   /**
-   * 删除接口
-   * @param itface 已有的接口实例
+   * 添加元数据类型
+   * @param metadataTypeOptions 元数据类型参数
    */
-  removeAbstractInterface(itface: AbstractInterface): void;
+  addMetadataType(metadataTypeOptions: Partial<MetadataType>): MetadataType;
 
-  removeAbstractInterface(options: string | AbstractInterface) {
-    let itface: AbstractInterface;
-    if (typeof options === 'string') {
-      itface = (this.interfaces as AbstractInterface[]).find((item) => item.name === options);
-      if (!itface) {
-        throw new Error('找不到接口 ' + options);
-      }
-    } else {
-      itface = options;
-    }
-    return itface.delete();
-  }
+  /**
+   * 添加元数据类型
+   * @param metadataType 已有的元数据类型实例
+   */
+  addMetadataType(metadataType: MetadataType): MetadataType;
 
-  __removeAbstractInterface(itface: AbstractInterface) {
-    const parentKey = itface.parentKey;
-    const params: Params = {
+  addMetadataType(options?: string | Partial<MetadataType> | MetadataType) {
+    const node = this._addMetadataType(options as any);
+    const index = this.metadataTypes.indexOf(node);
+    node.create({
+      index,
       parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: itface,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = itface.__v_raw || itface;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
+      parentKey: 'metadataTypes',
+    });
+    return node;
   }
 
   /**
-   * 删除端类型
-   * @param name 端类型名称
+   * 删除数据源
+   * @param name 数据源名称
    */
-  removeFrontendType(name: string): void;
+  removeDataSource(name: string): void;
 
   /**
-   * 删除端类型
-   * @param frontendType 已有的端类型实例
+   * 删除数据源
+   * @param dataSource 已有的数据源实例
    */
-  removeFrontendType(frontendType: FrontendType): void;
+  removeDataSource(dataSource: DataSource): void;
 
-  removeFrontendType(options: string | FrontendType) {
-    let frontendType: FrontendType;
+  removeDataSource(options: string | DataSource) {
+    let dataSource: DataSource;
     if (typeof options === 'string') {
-      frontendType = (this.frontendTypes as FrontendType[]).find((item) => item.name === options);
-      if (!frontendType) {
-        throw new Error('找不到端类型 ' + options);
+      dataSource = (this.dataSources as DataSource[]).find((item) => item.name === options);
+      if (!dataSource) {
+        throw new Error('找不到数据源 ' + options);
       }
     } else {
-      frontendType = options;
-    }
-    return frontendType.delete();
-  }
-
-  __removeFrontendType(frontendType: FrontendType) {
-    const parentKey = frontendType.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: frontendType,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = frontendType.__v_raw || frontendType;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
+      dataSource = options;
     }
-    return params;
+    return dataSource.delete();
   }
 
   /**
-   * 删除后端
-   * @param name 后端名称
+   * 删除数据结构
+   * @param name 数据结构名称
    */
-  removeBackend(name: string): void;
+  removeStructure(name: string): void;
 
   /**
-   * 删除后端
-   * @param backend 已有的后端实例
+   * 删除数据结构
+   * @param structure 已有的数据结构实例
    */
-  removeBackend(backend: Backend): void;
+  removeStructure(structure: Structure): void;
 
-  removeBackend(options: string | Backend) {
-    let backend: Backend;
-    if (typeof options === 'string') {
-      backend = this.backend;
-      if (!backend) {
-        throw new Error('找不到后端 ' + options);
+  removeStructure(options: string | Structure) {
+    let structure: Structure;
+    if (typeof options === 'string') {
+      structure = (this.structures as Structure[]).find((item) => item.name === options);
+      if (!structure) {
+        throw new Error('找不到数据结构 ' + options);
       }
     } else {
-      backend = options;
+      structure = options;
     }
-    return backend.delete();
+    return structure.delete();
   }
 
-  __removeBackend(backend: Backend) {
-    const parentKey = backend.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: backend,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = backend.__v_raw || backend;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
+  /**
+   * 删除枚举
+   * @param name 枚举名称
+   */
+  removeEnum(name: string): void;
+
+  /**
+   * 删除枚举
+   * @param enumeration 已有的枚举实例
+   */
+  removeEnum(enumeration: Enum): void;
+
+  removeEnum(options: string | Enum) {
+    let enumeration: Enum;
+    if (typeof options === 'string') {
+      enumeration = (this.enums as Enum[]).find((item) => item.name === options);
+      if (!enumeration) {
+        throw new Error('找不到枚举 ' + options);
+      }
+    } else {
+      enumeration = options;
+    }
+    return enumeration.delete();
+  }
+
+  /**
+   * 删除逻辑
+   * @param name 逻辑名称
+   */
+  removeLogic(name: string): void;
+
+  /**
+   * 删除逻辑
+   * @param logic 已有的逻辑实例
+   */
+  removeLogic(logic: Logic): void;
+
+  removeLogic(options: string | Logic) {
+    let logic: Logic;
+    if (typeof options === 'string') {
+      logic = (this.logics as Logic[]).find((item) => item.name === options);
+      if (!logic) {
+        throw new Error('找不到逻辑 ' + options);
+      }
+    } else {
+      logic = options;
+    }
+    return logic.delete();
+  }
+
+  /**
+   * 删除覆写逻辑
+   * @param name 覆写逻辑名称
+   */
+  removeOverriddenLogic(name: string): void;
+
+  /**
+   * 删除覆写逻辑
+   * @param overriddenLogic 已有的覆写逻辑实例
+   */
+  removeOverriddenLogic(overriddenLogic: OverriddenLogic): void;
+
+  removeOverriddenLogic(options: string | OverriddenLogic) {
+    let overriddenLogic: OverriddenLogic;
+    if (typeof options === 'string') {
+      overriddenLogic = (this.overriddenLogics as OverriddenLogic[]).find((item) => item.name === options);
+      if (!overriddenLogic) {
+        throw new Error('找不到覆写逻辑 ' + options);
+      }
+    } else {
+      overriddenLogic = options;
+    }
+    return overriddenLogic.delete();
+  }
+
+  /**
+   * 删除接口
+   * @param name 接口名称
+   */
+  removeInterface(name: string): void;
+
+  /**
+   * 删除接口
+   * @param itface 已有的接口实例
+   */
+  removeInterface(itface: AbstractInterface): void;
+
+  removeInterface(options: string | AbstractInterface) {
+    let itface: AbstractInterface;
+    if (typeof options === 'string') {
+      itface = (this.interfaces as AbstractInterface[]).find((item) => item.name === options);
+      if (!itface) {
+        throw new Error('找不到接口 ' + options);
+      }
+    } else {
+      itface = options;
+    }
+    return itface.delete();
+  }
+
+  /**
+   * 删除端类型
+   * @param name 端类型名称
+   */
+  removeFrontendType(name: string): void;
+
+  /**
+   * 删除端类型
+   * @param frontendType 已有的端类型实例
+   */
+  removeFrontendType(frontendType: FrontendType): void;
+
+  removeFrontendType(options: string | FrontendType) {
+    let frontendType: FrontendType;
+    if (typeof options === 'string') {
+      frontendType = (this.frontendTypes as FrontendType[]).find((item) => item.name === options);
+      if (!frontendType) {
+        throw new Error('找不到端类型 ' + options);
       }
+    } else {
+      frontendType = options;
     }
-    return params;
+    return frontendType.delete();
   }
 
   /**
@@ -3375,37 +3216,6 @@ export class App extends BaseNode {
     return process.delete();
   }
 
-  __removeProcess(process: Process) {
-    const parentKey = process.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: process,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = process.__v_raw || process;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除角色
    * @param name 角色名称
@@ -3431,109 +3241,47 @@ export class App extends BaseNode {
     return role.delete();
   }
 
-  __removeRole(role: Role) {
-    const parentKey = role.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: role,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = role.__v_raw || role;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
-   * 删除配置管理
-   * @param name 配置管理名称
+   * 删除模块
+   * @param name 模块名称
    */
-  removeConfiguration(name: string): void;
+  removeModuleInDependencies(name: string): void;
 
   /**
-   * 删除配置管理
-   * @param configuration 已有的配置管理实例
+   * 删除模块
+   * @param module 已有的模块实例
    */
-  removeConfiguration(configuration: Configuration): void;
+  removeModuleInDependencies(module: Module): void;
 
-  removeConfiguration(options: string | Configuration) {
-    let configuration: Configuration;
+  removeModuleInDependencies(options: string | Module) {
+    let module: Module;
     if (typeof options === 'string') {
-      configuration = this.configuration;
-      if (!configuration) {
-        throw new Error('找不到配置管理 ' + options);
+      module = (this.dependencies as Module[]).find((item) => item.name === options);
+      if (!module) {
+        throw new Error('找不到模块 ' + options);
       }
     } else {
-      configuration = options;
-    }
-    return configuration.delete();
-  }
-
-  __removeConfiguration(configuration: Configuration) {
-    const parentKey = configuration.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: configuration,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = configuration.__v_raw || configuration;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
+      module = options;
     }
-    return params;
+    return module.delete();
   }
 
   /**
    * 删除模块
    * @param name 模块名称
    */
-  removeModuleInDependencies(name: string): void;
+  removeModuleInInterfaceDependencies(name: string): void;
 
   /**
    * 删除模块
    * @param module 已有的模块实例
    */
-  removeModuleInDependencies(module: Module): void;
+  removeModuleInInterfaceDependencies(module: Module): void;
 
-  removeModuleInDependencies(options: string | Module) {
+  removeModuleInInterfaceDependencies(options: string | Module) {
     let module: Module;
     if (typeof options === 'string') {
-      module = (this.dependencies as Module[]).find((item) => item.name === options);
+      module = (this.interfaceDependencies as Module[]).find((item) => item.name === options);
       if (!module) {
         throw new Error('找不到模块 ' + options);
       }
@@ -3547,15 +3295,15 @@ export class App extends BaseNode {
    * 删除连接器
    * @param name 连接器名称
    */
-  removeConnectorInDependencies(name: string): void;
+  removeConnector(name: string): void;
 
   /**
    * 删除连接器
    * @param connector 已有的连接器实例
    */
-  removeConnectorInDependencies(connector: Connector): void;
+  removeConnector(connector: Connector): void;
 
-  removeConnectorInDependencies(options: string | Connector) {
+  removeConnector(options: string | Connector) {
     let connector: Connector;
     if (typeof options === 'string') {
       connector = (this.dependencies as Connector[]).find((item) => item.name === options);
@@ -3569,115 +3317,55 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除模块
-   * @param name 模块名称
+   * 删除鉴权逻辑
+   * @param name 鉴权逻辑名称
    */
-  removeModuleInInterfaceDependencies(name: string): void;
+  removeAuthLogic(name: string): void;
 
   /**
-   * 删除模块
-   * @param module 已有的模块实例
+   * 删除鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
    */
-  removeModuleInInterfaceDependencies(module: Module): void;
+  removeAuthLogic(authLogic: AuthLogic): void;
 
-  removeModuleInInterfaceDependencies(options: string | Module) {
-    let module: Module;
+  removeAuthLogic(options: string | AuthLogic) {
+    let authLogic: AuthLogic;
     if (typeof options === 'string') {
-      module = (this.interfaceDependencies as Module[]).find((item) => item.name === options);
-      if (!module) {
-        throw new Error('找不到模块 ' + options);
+      authLogic = (this.authLogics as AuthLogic[]).find((item) => item.name === options);
+      if (!authLogic) {
+        throw new Error('找不到鉴权逻辑 ' + options);
       }
     } else {
-      module = options;
-    }
-    return module.delete();
-  }
-
-  __removeModule(module: Module) {
-    const parentKey = module.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: module,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = module.__v_raw || module;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
+      authLogic = options;
     }
-    return params;
+    return authLogic.delete();
   }
 
   /**
-   * 删除集成
-   * @param name 集成名称
+   * 删除调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称
    */
-  removeIntegration(name: string): void;
+  removeAuthLogicForCallInterface(name: string): void;
 
   /**
-   * 删除集成
-   * @param integration 已有的集成实例
+   * 删除调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  removeIntegration(integration: Integration): void;
+  removeAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): void;
 
-  removeIntegration(options: string | Integration) {
-    let integration: Integration;
+  removeAuthLogicForCallInterface(options: string | AuthLogicForCallInterface) {
+    let authLogicForCallInterface: AuthLogicForCallInterface;
     if (typeof options === 'string') {
-      integration = this.integration;
-      if (!integration) {
-        throw new Error('找不到集成 ' + options);
+      authLogicForCallInterface = (this.authLogicsForCallInterface as AuthLogicForCallInterface[]).find(
+        (item) => item.name === options,
+      );
+      if (!authLogicForCallInterface) {
+        throw new Error('找不到调用接口的鉴权逻辑 ' + options);
       }
     } else {
-      integration = options;
-    }
-    return integration.delete();
-  }
-
-  __removeIntegration(integration: Integration) {
-    const parentKey = integration.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: integration,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = integration.__v_raw || integration;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
+      authLogicForCallInterface = options;
     }
-    return params;
+    return authLogicForCallInterface.delete();
   }
 
   /**
@@ -3705,37 +3393,6 @@ export class App extends BaseNode {
     return connection.delete();
   }
 
-  __removeConnection(connection: Connection) {
-    const parentKey = connection.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: connection,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = connection.__v_raw || connection;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除触发器启动器
    * @param name 触发器启动器名称
@@ -3761,37 +3418,6 @@ export class App extends BaseNode {
     return triggerLauncher.delete();
   }
 
-  __removeTriggerLauncher(triggerLauncher: TriggerLauncher) {
-    const parentKey = triggerLauncher.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: triggerLauncher,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = triggerLauncher.__v_raw || triggerLauncher;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除元数据类型
    * @param name 元数据类型名称
@@ -3817,37 +3443,6 @@ export class App extends BaseNode {
     return metadataType.delete();
   }
 
-  __removeMetadataType(metadataType: MetadataType) {
-    const parentKey = metadataType.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: metadataType,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = metadataType.__v_raw || metadataType;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
@@ -3938,14 +3533,30 @@ export class App extends BaseNode {
    */
   composeCache: composeCacheType = {};
 
-
   /**
-   * 获取组合节点
+   * 判断缓存是否为空
    */
-  getCompose(path: string[]) {
-    let compose = this.composeCache;
-    path.forEach((key) => {
-      compose = compose?.[key];
+  isComposeCacheEmpty() {
+    const isEmpty = (composeCache: composeCacheType): boolean => {
+      let result = true;
+      for (const key in composeCache) {
+        if (key !== 'nodes') {
+          result = result && isEmpty(composeCache[key]);
+        }
+      }
+      return result && !composeCache?.nodes?.length;
+    };
+
+    return isEmpty(this.composeCache);
+  }
+
+  /**
+   * 获取组合节点
+   */
+  getCompose(path: string[]) {
+    let compose = this.composeCache;
+    path.forEach((key) => {
+      compose = compose?.[key];
     });
     return compose || null;
   }
@@ -3969,11 +3580,20 @@ export class App extends BaseNode {
     path.forEach((key, index) => {
       if (index === path.length - 1) {
         if (compose?.[key]?.nodes) {
+          // 需要判断下nodes里面是否已经存在
           if (Array.isArray(node)) {
-            compose[key].nodes.push(...node);
+            node.forEach((item) => {
+              if (!compose[key].nodes.find((it) => it === item)) {
+                compose[key].nodes.push(item);
+              }
+            });
           } else {
-            compose[key].nodes.push(node);
+            if (!compose[key].nodes.find((it) => it === node)) {
+              compose[key].nodes.push(node);
+            }
           }
+          // 去重
+          compose[key].nodes = Array.from(new Set(compose[key].nodes));
         } else {
           if (!compose?.[key]) {
             compose[key] = {};
@@ -3998,17 +3618,28 @@ export class App extends BaseNode {
 
     const delNodes = (_compose: composeCacheType) => {
       if (_compose?.nodes) {
-        for(let key in _compose) {
+        for (const key in _compose) {
           if (key !== 'nodes') {
             delNodes(_compose[key]);
           }
         }
-        _compose.nodes.forEach((node) => {
-          node.delete();
-        })
+        const arr = [..._compose.nodes] || [];
+        const triggerNode: BaseNode[] = []; // 触点放在最后删
+        arr.forEach((node) => {
+          if (node.name === path?.[0]) {
+            triggerNode.push(node);
+          } else {
+            node && node.delete();
+          }
+        });
+
+        triggerNode.forEach((node) => {
+          node && node.delete();
+        });
+
         _compose.nodes = [];
       }
-    }
+    };
 
     this.emit('collect:start', {
       actionMsg: '删除同一分组节点',
@@ -4024,19 +3655,78 @@ export class App extends BaseNode {
   }
 
   /**
-   * 释放分组内所有节点
+   * 释放分组内所有节点， 包括子分组
    */
   releaseComposeNode(path: string[]) {
     if (!Array.isArray(path)) return;
     let compose = this.composeCache;
-    path.forEach((key, index) => {
-      if (index === path.length - 1) {
-        const nodes = compose?.[key]?.nodes || [];
-        nodes.forEach((node) => {
+
+    const releaseNodes = (_compose: composeCacheType) => {
+      if (_compose?.nodes) {
+        for (const key in _compose) {
+          if (key !== 'nodes') {
+            releaseNodes(_compose[key]);
+          }
+        }
+        _compose.nodes.forEach((node) => {
           node.update({
-            composedBy: [],
+            composedBy: undefined,
           });
-        })
+          // 临时兼容性代码，后续抽离成插件化
+          if (node.tag === 'u-linear-layout') {
+            const attr = node.bindAttrs.find((it: any) => it.name === 'TableDesignerLocked');
+            if (attr) {
+              attr.delete();
+            }
+          }
+        });
+        _compose.nodes = [];
+      }
+    };
+
+    this.emit('collect:start', {
+      actionMsg: '释放节点',
+    });
+    path.forEach((key, index) => {
+      if (index === path.length - 1) {
+        releaseNodes(compose?.[key]);
+      } else {
+        compose = compose[key];
+      }
+    });
+    this.emit('collect:end');
+  }
+
+  /**
+   * 删除分组内的某一个
+   */
+  deleteComposeNode(path: string[], node: BaseNode) {
+    if (!node) return;
+    let compose = this.composeCache;
+    path.forEach((key, index) => {
+      if (index === path.length - 1) {
+        if (compose?.[key]?.nodes) {
+          const index = compose[key].nodes.findIndex((it) => it === node);
+          if (index > -1) {
+            compose[key].nodes.splice(index, 1);
+          }
+        }
+      } else {
+        compose = compose[key];
+      }
+    });
+  }
+
+  /**
+   * 清空某一分组
+   */
+  clearComposeNodes(path: string[]) {
+    let compose = this.composeCache;
+    path.forEach((key, index) => {
+      if (index === path.length - 1) {
+        if (compose?.[key]) {
+          delete compose[key];
+        }
       } else {
         compose = compose[key];
       }
@@ -4061,7 +3751,7 @@ export class App extends BaseNode {
   findNodeByCompleteName(originCompleteName: string) {
     let completeName = originCompleteName;
     // 是否是来自编辑态的自定义连接器
-    const isFromEditableConnector = completeName.endsWith(CUSTOM_CONNECTOR_EDITABLE_SUFFIX);
+    const isFromEditableConnector = completeName?.endsWith(CUSTOM_CONNECTOR_EDITABLE_SUFFIX);
     if (isFromEditableConnector) {
       // 为了查找到真实的结构，需要去掉编辑态的后缀
       completeName = completeName.replace(CUSTOM_CONNECTOR_EDITABLE_SUFFIX, '');
@@ -4077,15 +3767,17 @@ export class App extends BaseNode {
     const mod = 0;
     const modulesMap: any = {
       // v3.3 版本引入自定义连接器，在配置自定义连接器时需要同步支持内部数据结构使用，所以这里做扩展
-      extensions: [...node.dependencies, ...(node?.integration?.connectors || [])],
+      extensions: [...(node?.dependencies || []), ...(node?.integration?.connectors || [])],
       apis: node.interfaceDependencies,
       components: node.componentDependencies,
     };
     const modules = modulesMap[start];
     if (Array.isArray(modules)) {
       const moduleName = nameArr.shift();
-      if(isFromEditableConnector) {
-        node = modules.find((moduleItem) => moduleItem.name === moduleName && moduleItem?.parentNode?.concept === 'Integration');
+      if (isFromEditableConnector) {
+        node = modules.find(
+          (moduleItem) => moduleItem.name === moduleName && moduleItem?.parentNode?.concept === 'Integration',
+        );
       } else {
         node = modules.find((moduleItem) => moduleItem.name === moduleName);
       }
@@ -4128,9 +3820,7 @@ export class App extends BaseNode {
     packageInfo.template.version = framework.version;
 
     packageInfo.ui.name = scope === 'h5' ? ui.h5.name : ui.pc.name;
-    packageInfo.ui.version = scope === 'h5'
-        ? ui.h5.version
-        : ui.pc.version;
+    packageInfo.ui.version = scope === 'h5' ? ui.h5.version : ui.pc.version;
 
     return packageInfo;
   }
@@ -4204,7 +3894,7 @@ export class App extends BaseNode {
         (frontends || []).forEach((frontend) => {
           if (frontend.type === scope) {
             const jsName = `${prefix}/packages/${
-              prefixPath ? prefixPath + '/' : ''
+              prefixPath ? `${prefixPath}/` : ''
             }${name}@${version}/dist-theme/index.js`;
             if (!existingSet.has(jsName)) {
               existingSet.add(jsName);
@@ -4534,15 +4224,6 @@ export class App extends BaseNode {
 
   __databaseTypeMap: any = {};
 
-  getAuthLogicExistingNames(excludedList: Array<AuthLogic> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.authLogics as AuthLogic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-
-  getAuthLogicUniqueName(name = 'authentication1') {
-    return utils.unique(name, this.getAuthLogicExistingNames(), undefined, true);
-  }
-
   getAuthInterfaceUniqueName(name = 'authInterface1') {
     // never used
   }
@@ -4554,16 +4235,6 @@ export class App extends BaseNode {
       ?.values.find((item) => item.env === this.curDeployEnv)?.value;
   }
 
-  // FIXME: 没有设置 dontGenGetUniqueName 为什么 不会生成 唯一标识逻辑？？？
-  getConnectorExistingNames(excludedList: Array<Module> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.dependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-
-  getConnectorUniqueName(name = 'connector1') {
-    return utils.unique(name, this.getConnectorExistingNames(), undefined, false);
-  }
-
   /** 根据名称获取 triggerLauncher */
   getTriggerLauncherByName(name: string) {
     return this.triggerLaunchers.find((item) => item.name === name);
@@ -4580,363 +4251,6 @@ export class App extends BaseNode {
     return ((this.dependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
   }
 
-  getAuthLogicForCallInterfaceExistingNames(excludedList: Array<AuthLogicForCallInterface> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.authLogicsForCallInterface as AuthLogicForCallInterface[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item.name);
-  }
-  getAuthLogicForCallInterfaceUniqueName(name = 'authLogicForCallInterface1') {
-    return utils.unique(name, this.getAuthLogicForCallInterfaceExistingNames(), undefined, false);
-  }
-  //todo 替换生成
-  getInterfaceExistingNames(excludedList: Array<Interface> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.interfaces as Interface[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-  getInterfaceUniqueName(name = 'Interface1') {
-    return utils.unique(name, this.getInterfaceExistingNames(), undefined, true);
-  }
-
-  /**
-   * 插入接口
-   * @internal
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
-   */
-  _insertInterfaceInInterfacesAt(name: string, index: number): Interface;
-
-  /**
-   * 插入接口
-   * @internal
-   * @param itfaceOptions 接口参数
-   */
-  _insertInterfaceInInterfacesAt(itfaceOptions: Partial<Interface>, index: number): Interface;
-
-  /**
-   * 插入接口
-   * @internal
-   * @param itface 已有的接口实例
-   */
-  _insertInterfaceInInterfacesAt(itface: Interface, index: number): Interface;
-
-  _insertInterfaceInInterfacesAt(options: string | Partial<Interface> | Interface, index: number) {
-    const itfaceOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'interfaces' };
-    const Interface = getConceptConstructor('Interface');
-    let itface: Interface;
-    if (!options) {
-      itface = Interface.from(
-        {
-          ...itfaceOptions,
-          name: this.getInterfaceUniqueName(),
-        },
-        this,
-        'interfaces',
-      );
-    } else if (typeof options === 'string') {
-      itface = Interface.from(
-        {
-          ...itfaceOptions,
-          name: options,
-        },
-        this,
-        'interfaces',
-      );
-    } else if (asserts.isInterface(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      itface = options;
-      Object.assign(itface, relationOptions);
-    } else {
-      itface = Interface.from(
-        {
-          ...itfaceOptions,
-          ...options,
-        },
-        this,
-        'interfaces',
-      );
-    }
-    this.interfaces.splice(index, 0, itface);
-    return itface;
-  }
-
-  /**
-   * 插入接口
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
-   */
-  insertInterfaceInInterfacesAt(name: string, index: number): Interface;
-
-  /**
-   * 插入接口
-   * @param itfaceOptions 接口参数
-   */
-  insertInterfaceInInterfacesAt(itfaceOptions: Partial<Interface>, index: number): Interface;
-
-  /**
-   * 插入接口
-   * @param itface 已有的接口实例
-   */
-  insertInterfaceInInterfacesAt(itface: Interface, index: number): Interface;
-
-  insertInterfaceInInterfacesAt(options: string | Partial<Interface> | Interface, index: number) {
-    const node = this._insertInterfaceInInterfacesAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'interfaces',
-    });
-    return node;
-  }
-
-  /**
-   * 添加接口
-   * @internal
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
-   */
-  _addInterfaceInInterfaces(name?: string): Interface;
-
-  /**
-   * 添加接口
-   * @internal
-   * @param itfaceOptions 接口参数
-   */
-  _addInterfaceInInterfaces(itfaceOptions: Partial<Interface>): Interface;
-
-  /**
-   * 添加接口
-   * @internal
-   * @param itface 已有的接口实例
-   */
-  _addInterfaceInInterfaces(itface: Interface): Interface;
-
-  _addInterfaceInInterfaces(options?: string | Partial<Interface> | Interface) {
-    const index = 0;
-    return this._insertInterfaceInInterfacesAt(options as any, index);
-  }
-
-  /**
-   * 添加接口
-   * @internal
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
-   */
-  addInterfaceInInterfaces(name?: string): Interface;
-
-  /**
-   * 添加接口
-   * @param itfaceOptions 接口参数
-   */
-  addInterfaceInInterfaces(itfaceOptions: Partial<Interface>): Interface;
-
-  /**
-   * 添加接口
-   * @param itface 已有的接口实例
-   */
-  addInterfaceInInterfaces(itface: Interface): Interface;
-
-  addInterfaceInInterfaces(options?: string | Partial<Interface> | Interface) {
-    const node = this._addInterfaceInInterfaces(options as any);
-    const index = this.interfaces.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'interfaces',
-    });
-    return node;
-  }
-
-  /**
-   * 插入鉴权接口
-   * @internal
-   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
-   */
-  _insertAuthInterfaceInInterfacesAt(name: string, index: number): AuthInterface;
-
-  /**
-   * 插入鉴权接口
-   * @internal
-   * @param itfaceOptions 鉴权接口参数
-   */
-  _insertAuthInterfaceInInterfacesAt(itfaceOptions: Partial<AuthInterface>, index: number): AuthInterface;
-
-  /**
-   * 插入鉴权接口
-   * @internal
-   * @param itface 已有的鉴权接口实例
-   */
-  _insertAuthInterfaceInInterfacesAt(itface: AuthInterface, index: number): AuthInterface;
-
-  _insertAuthInterfaceInInterfacesAt(options: string | Partial<AuthInterface> | AuthInterface, index: number) {
-    const itfaceOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'interfaces' };
-    const AuthInterface = getConceptConstructor('AuthInterface');
-    let itface: AuthInterface;
-    if (!options) {
-      itface = AuthInterface.from(
-        {
-          ...itfaceOptions,
-          name: this.getAuthInterfaceUniqueName(),
-        },
-        this,
-        'interfaces',
-      );
-    } else if (typeof options === 'string') {
-      itface = AuthInterface.from(
-        {
-          ...itfaceOptions,
-          name: options,
-        },
-        this,
-        'interfaces',
-      );
-    } else if (asserts.isAuthInterface(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      itface = options;
-      Object.assign(itface, relationOptions);
-    } else {
-      itface = AuthInterface.from(
-        {
-          ...itfaceOptions,
-          ...options,
-        },
-        this,
-        'interfaces',
-      );
-    }
-    this.interfaces.splice(index, 0, itface);
-    return itface;
-  }
-
-  /**
-   * 插入鉴权接口
-   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
-   */
-  insertAuthInterfaceInInterfacesAt(name: string, index: number): AuthInterface;
-
-  /**
-   * 插入鉴权接口
-   * @param itfaceOptions 鉴权接口参数
-   */
-  insertAuthInterfaceInInterfacesAt(itfaceOptions: Partial<AuthInterface>, index: number): AuthInterface;
-
-  /**
-   * 插入鉴权接口
-   * @param itface 已有的鉴权接口实例
-   */
-  insertAuthInterfaceInInterfacesAt(itface: AuthInterface, index: number): AuthInterface;
-
-  insertAuthInterfaceInInterfacesAt(options: string | Partial<AuthInterface> | AuthInterface, index: number) {
-    const node = this._insertAuthInterfaceInInterfacesAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'interfaces',
-    });
-    return node;
-  }
-
-  /**
-   * 添加鉴权接口
-   * @internal
-   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
-   */
-  _addAuthInterfaceInInterfaces(name?: string): AuthInterface;
-
-  /**
-   * 添加鉴权接口
-   * @internal
-   * @param itfaceOptions 鉴权接口参数
-   */
-  _addAuthInterfaceInInterfaces(itfaceOptions: Partial<AuthInterface>): AuthInterface;
-
-  /**
-   * 添加鉴权接口
-   * @internal
-   * @param itface 已有的鉴权接口实例
-   */
-  _addAuthInterfaceInInterfaces(itface: AuthInterface): AuthInterface;
-
-  _addAuthInterfaceInInterfaces(options?: string | Partial<AuthInterface> | AuthInterface) {
-    const index = 0;
-    return this._insertAuthInterfaceInInterfacesAt(options as any, index);
-  }
-
-  /**
-   * 添加鉴权接口
-   * @internal
-   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
-   */
-  addAuthInterfaceInInterfaces(name?: string): AuthInterface;
-
-  /**
-   * 添加鉴权接口
-   * @param itfaceOptions 鉴权接口参数
-   */
-  addAuthInterfaceInInterfaces(itfaceOptions: Partial<AuthInterface>): AuthInterface;
-
-  /**
-   * 添加鉴权接口
-   * @param itface 已有的鉴权接口实例
-   */
-  addAuthInterfaceInInterfaces(itface: AuthInterface): AuthInterface;
-
-  addAuthInterfaceInInterfaces(options?: string | Partial<AuthInterface> | AuthInterface) {
-    const node = this._addAuthInterfaceInInterfaces(options as any);
-    const index = this.interfaces.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'interfaces',
-    });
-    return node;
-  }
-
-  /**
-   * 删除鉴权接口
-   * @param name 鉴权接口名称
-   */
-  removeAuthInterfaceInInterfaces(name: string): void;
-
-  /**
-   * 删除鉴权接口
-   * @param itface 已有的鉴权接口实例
-   */
-  removeAuthInterfaceInInterfaces(itface: AuthInterface): void;
-
-  removeAuthInterfaceInInterfaces(options: string | AuthInterface) {
-    let itface: AuthInterface;
-    if (typeof options === 'string') {
-      itface = (this.interfaces as AuthInterface[]).find((item) => item.name === options);
-      if (!itface) {
-        throw new Error('找不到鉴权接口 ' + options);
-      }
-    } else {
-      itface = options;
-    }
-    return itface.delete();
-  }
-
-  __removeInterface(itface: Interface) {
-    const parentKey = itface.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: itface,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      if (Array.isArray((this as any)[parentKey])) {
-        const index = (this as any)[parentKey].indexOf(itface);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((this as any)[parentKey] === itface) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
-      }
-    }
-    return params;
-  }
   /** hank */
   // setConnector() {
   //   const [a, b, c, d, e, f] = this.connections;