@lcap/nasl 3.5.0-beta.1 → 3.5.0-beta.3

package/src/concepts/App__.ts

@@ -5,6 +5,8 @@ import type TypeAnnotation from './TypeAnnotation__';
 import type View from './View__';
 import type AuthInterface from './AuthInterface__';
 import type Interface from './Interface__';
+import type Frontend from './Frontend__';
+import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 
 export interface AssetsInfo {
   js: Array<string>;
@@ -39,8 +41,8 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
-import * as Type from './utils/types';
-import * as Assert from './utils/asserts';
+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__';
@@ -49,7 +51,7 @@ import type Enum from './Enum__';
 import type Logic from './Logic__';
 import type OverriddenLogic from './OverriddenLogic__';
 import type AbstractInterface from './AbstractInterface__';
-import type Frontend from './Frontend__';
+import type FrontendType from './FrontendType__';
 import Backend from './Backend__';
 import type Process from './Process__';
 import type Role from './Role__';
@@ -67,19 +69,17 @@ import type MetadataType from './MetadataType__';
  * 应用
  */
 @concept('应用')
-// @ts-ignore
 export class App extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'App';
+  static readonly ConceptName: string = 'App';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 应用 Id
    */
   @property()
-  // @ts-ignore
   id!: string;
 
   /**
@@ -93,56 +93,48 @@ export class App extends BaseNode {
    * IDE 版本
    */
   @property()
-  // @ts-ignore
   ideVersion!: string;
 
   /**
    * 应用标识
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
    * 应用标题
    */
   @property()
-  // @ts-ignore
   title!: string;
 
   /**
    * 应用图标
    */
   @property()
-  // @ts-ignore
   icon!: string;
 
   /**
    * 应用描述
    */
   @property()
-  // @ts-ignore
   desc!: string;
 
   /**
    * 域名
    */
   @property()
-  // @ts-ignore
   dnsAddr!: string;
 
   /**
    * 是否有用户中心
    */
   @property()
-  // @ts-ignore
   hasUserCenter!: boolean;
 
   /**
    * 是否有权限
    */
   @property()
-  // @ts-ignore
   hasAuth!: boolean;
 
   /**
@@ -206,14 +198,14 @@ export class App extends BaseNode {
   interfaces: Array<AbstractInterface> = [];
 
   /**
-   * 前端列表
+   * 端类型列表
    */
   @property({
-    objectRef: 'Frontend',
+    objectRef: 'FrontendType',
     isArray: true,
     defaultValue: [],
   })
-  frontends: Array<Frontend> = [];
+  frontendTypes: Array<FrontendType> = [];
 
   /**
    * 后端
@@ -277,7 +269,6 @@ export class App extends BaseNode {
   @property({
     objectRef: 'Integration',
   })
-  // @ts-ignore
   integration!: Integration;
 
   /**
@@ -417,7 +408,7 @@ export class App extends BaseNode {
         this,
         'dataSources',
       );
-    } else if (Assert.isDataSource(options)) {
+    } else if (asserts.isDataSource(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       dataSource = options;
       Object.assign(dataSource, relationOptions);
@@ -571,7 +562,7 @@ export class App extends BaseNode {
         this,
         'structures',
       );
-    } else if (Assert.isStructure(options)) {
+    } else if (asserts.isStructure(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       structure = options;
       Object.assign(structure, relationOptions);
@@ -725,7 +716,7 @@ export class App extends BaseNode {
         this,
         'enums',
       );
-    } else if (Assert.isEnum(options)) {
+    } else if (asserts.isEnum(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       enumeration = options;
       Object.assign(enumeration, relationOptions);
@@ -879,7 +870,7 @@ export class App extends BaseNode {
         this,
         'logics',
       );
-    } else if (Assert.isLogic(options)) {
+    } else if (asserts.isLogic(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logic = options;
       Object.assign(logic, relationOptions);
@@ -1025,7 +1016,7 @@ export class App extends BaseNode {
         this,
         'authLogics',
       );
-    } else if (Assert.isAuthLogic(options)) {
+    } else if (asserts.isAuthLogic(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       authLogic = options;
       Object.assign(authLogic, relationOptions);
@@ -1183,7 +1174,7 @@ export class App extends BaseNode {
         this,
         'authLogicsForCallInterface',
       );
-    } else if (Assert.isAuthLogicForCallInterface(options)) {
+    } else if (asserts.isAuthLogicForCallInterface(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       authLogicForCallInterface = options;
       Object.assign(authLogicForCallInterface, relationOptions);
@@ -1360,7 +1351,7 @@ export class App extends BaseNode {
         this,
         'overriddenLogics',
       );
-    } else if (Assert.isOverriddenLogic(options)) {
+    } else if (asserts.isOverriddenLogic(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       overriddenLogic = options;
       Object.assign(overriddenLogic, relationOptions);
@@ -1472,156 +1463,158 @@ export class App extends BaseNode {
     return utils.unique(name, this.getAbstractInterfaceExistingNames(), undefined, true);
   }
 
-  getFrontendExistingNames(excludedList: Array<Frontend> = []) {
+  getFrontendTypeExistingNames(excludedList: Array<FrontendType> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.frontends as Frontend[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.frontendTypes as FrontendType[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item?.name);
   }
-  getFrontendUniqueName(name = 'frontend1') {
-    return utils.unique(name, this.getFrontendExistingNames(), undefined, true);
+  getFrontendTypeUniqueName(name = 'frontendType1') {
+    return utils.unique(name, this.getFrontendTypeExistingNames(), undefined, true);
   }
 
   /**
-   * 插入前端
+   * 插入端类型
    * @internal
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * @param name 端类型名称，如果不填会自动生成一个唯一名称
    */
-  _insertFrontendAt(name: string, index: number): Frontend;
+  _insertFrontendTypeAt(name: string, index: number): FrontendType;
 
   /**
-   * 插入前端
+   * 插入端类型
    * @internal
-   * @param frontendOptions 前端参数
+   * @param frontendTypeOptions 端类型参数
    */
-  _insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
+  _insertFrontendTypeAt(frontendTypeOptions: Partial<FrontendType>, index: number): FrontendType;
 
   /**
-   * 插入前端
+   * 插入端类型
    * @internal
-   * @param frontend 已有的前端实例
+   * @param frontendType 已有的端类型实例
    */
-  _insertFrontendAt(frontend: Frontend, index: number): Frontend;
+  _insertFrontendTypeAt(frontendType: FrontendType, index: number): FrontendType;
 
-  _insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
-    const frontendOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'frontends' };
-    const Frontend = getConceptConstructor('Frontend');
-    let frontend: Frontend;
+  _insertFrontendTypeAt(options: string | Partial<FrontendType> | FrontendType, index: number) {
+    const frontendTypeOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'frontendTypes' };
+    const FrontendType = getConceptConstructor('FrontendType');
+    let frontendType: FrontendType;
     if (!options) {
-      frontend = Frontend.from(
+      frontendType = FrontendType.from(
         {
-          ...frontendOptions,
-          name: this.getFrontendUniqueName(),
+          ...frontendTypeOptions,
+          name: this.getFrontendTypeUniqueName(),
         },
         this,
-        'frontends',
+        'frontendTypes',
       );
     } else if (typeof options === 'string') {
-      frontend = Frontend.from(
+      frontendType = FrontendType.from(
         {
-          ...frontendOptions,
+          ...frontendTypeOptions,
           name: options,
         },
         this,
-        'frontends',
+        'frontendTypes',
       );
-    } else if (Assert.isFrontend(options)) {
+    } else if (asserts.isFrontendType(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      frontend = options;
-      Object.assign(frontend, relationOptions);
+      frontendType = options;
+      Object.assign(frontendType, relationOptions);
     } else {
-      frontend = Frontend.from(
+      frontendType = FrontendType.from(
         {
-          ...frontendOptions,
+          ...frontendTypeOptions,
           ...options,
         },
         this,
-        'frontends',
+        'frontendTypes',
       );
     }
-    this.frontends.splice(index, 0, frontend);
-    return frontend;
+    this.frontendTypes.splice(index, 0, frontendType);
+    return frontendType;
   }
 
   /**
-   * 插入前端
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * 插入端类型
+   * @param name 端类型名称，如果不填会自动生成一个唯一名称
    */
-  insertFrontendAt(name: string, index: number): Frontend;
+  insertFrontendTypeAt(name: string, index: number): FrontendType;
 
   /**
-   * 插入前端
-   * @param frontendOptions 前端参数
+   * 插入端类型
+   * @param frontendTypeOptions 端类型参数
    */
-  insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
+  insertFrontendTypeAt(frontendTypeOptions: Partial<FrontendType>, index: number): FrontendType;
 
   /**
-   * 插入前端
-   * @param frontend 已有的前端实例
+   * 插入端类型
+   * @param frontendType 已有的端类型实例
    */
-  insertFrontendAt(frontend: Frontend, index: number): Frontend;
+  insertFrontendTypeAt(frontendType: FrontendType, index: number): FrontendType;
 
-  insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
-    const node = this._insertFrontendAt(options as any, index);
+  insertFrontendTypeAt(options: string | Partial<FrontendType> | FrontendType, index: number) {
+    const node = this._insertFrontendTypeAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'frontends',
+      parentKey: 'frontendTypes',
     });
     return node;
   }
 
   /**
-   * 添加前端
+   * 添加端类型
    * @internal
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * @param name 端类型名称，如果不填会自动生成一个唯一名称
    */
-  _addFrontend(name?: string): Frontend;
+  _addFrontendType(name?: string): FrontendType;
 
   /**
-   * 添加前端
+   * 添加端类型
    * @internal
-   * @param frontendOptions 前端参数
+   * @param frontendTypeOptions 端类型参数
    */
-  _addFrontend(frontendOptions: Partial<Frontend>): Frontend;
+  _addFrontendType(frontendTypeOptions: Partial<FrontendType>): FrontendType;
 
   /**
-   * 添加前端
+   * 添加端类型
    * @internal
-   * @param frontend 已有的前端实例
+   * @param frontendType 已有的端类型实例
    */
-  _addFrontend(frontend: Frontend): Frontend;
+  _addFrontendType(frontendType: FrontendType): FrontendType;
 
-  _addFrontend(options?: string | Partial<Frontend> | Frontend) {
-    const index = this.frontends.length;
-    return this._insertFrontendAt(options as any, index);
+  _addFrontendType(options?: string | Partial<FrontendType> | FrontendType) {
+    const index = this.frontendTypes.length;
+    return this._insertFrontendTypeAt(options as any, index);
   }
 
   /**
-   * 添加前端
+   * 添加端类型
    * @internal
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * @param name 端类型名称，如果不填会自动生成一个唯一名称
    */
-  addFrontend(name?: string): Frontend;
+  addFrontendType(name?: string): FrontendType;
 
   /**
-   * 添加前端
-   * @param frontendOptions 前端参数
+   * 添加端类型
+   * @param frontendTypeOptions 端类型参数
    */
-  addFrontend(frontendOptions: Partial<Frontend>): Frontend;
+  addFrontendType(frontendTypeOptions: Partial<FrontendType>): FrontendType;
 
   /**
-   * 添加前端
-   * @param frontend 已有的前端实例
+   * 添加端类型
+   * @param frontendType 已有的端类型实例
    */
-  addFrontend(frontend: Frontend): Frontend;
+  addFrontendType(frontendType: FrontendType): FrontendType;
 
-  addFrontend(options?: string | Partial<Frontend> | Frontend) {
-    const node = this._addFrontend(options as any);
-    const index = this.frontends.indexOf(node);
+  addFrontendType(options?: string | Partial<FrontendType> | FrontendType) {
+    const node = this._addFrontendType(options as any);
+    const index = this.frontendTypes.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'frontends',
+      parentKey: 'frontendTypes',
     });
     return node;
   }
@@ -1678,7 +1671,7 @@ export class App extends BaseNode {
         this,
         'processes',
       );
-    } else if (Assert.isProcess(options)) {
+    } else if (asserts.isProcess(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       process = options;
       Object.assign(process, relationOptions);
@@ -1832,7 +1825,7 @@ export class App extends BaseNode {
         this,
         'roles',
       );
-    } else if (Assert.isRole(options)) {
+    } else if (asserts.isRole(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       role = options;
       Object.assign(role, relationOptions);
@@ -1986,7 +1979,7 @@ export class App extends BaseNode {
         this,
         'dependencies',
       );
-    } else if (Assert.isModule(options)) {
+    } else if (asserts.isModule(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       module = options;
       Object.assign(module, relationOptions);
@@ -2132,7 +2125,7 @@ export class App extends BaseNode {
         this,
         'dependencies',
       );
-    } else if (Assert.isConnector(options)) {
+    } else if (asserts.isConnector(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       connector = options;
       Object.assign(connector, relationOptions);
@@ -2278,7 +2271,7 @@ export class App extends BaseNode {
         this,
         'interfaceDependencies',
       );
-    } else if (Assert.isModule(options)) {
+    } else if (asserts.isModule(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       module = options;
       Object.assign(module, relationOptions);
@@ -2434,7 +2427,7 @@ export class App extends BaseNode {
         this,
         'connections',
       );
-    } else if (Assert.isConnection(options)) {
+    } else if (asserts.isConnection(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       connection = options;
       Object.assign(connection, relationOptions);
@@ -2590,7 +2583,7 @@ export class App extends BaseNode {
         this,
         'triggerLaunchers',
       );
-    } else if (Assert.isTriggerLauncher(options)) {
+    } else if (asserts.isTriggerLauncher(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       triggerLauncher = options;
       Object.assign(triggerLauncher, relationOptions);
@@ -2746,7 +2739,7 @@ export class App extends BaseNode {
         this,
         'metadataTypes',
       );
-    } else if (Assert.isMetadataType(options)) {
+    } else if (asserts.isMetadataType(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       metadataType = options;
       Object.assign(metadataType, relationOptions);
@@ -3239,45 +3232,45 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除前端
-   * @param name 前端名称
+   * 删除端类型
+   * @param name 端类型名称
    */
-  removeFrontend(name: string): void;
+  removeFrontendType(name: string): void;
 
   /**
-   * 删除前端
-   * @param frontend 已有的前端实例
+   * 删除端类型
+   * @param frontendType 已有的端类型实例
    */
-  removeFrontend(frontend: Frontend): void;
+  removeFrontendType(frontendType: FrontendType): void;
 
-  removeFrontend(options: string | Frontend) {
-    let frontend: Frontend;
+  removeFrontendType(options: string | FrontendType) {
+    let frontendType: FrontendType;
     if (typeof options === 'string') {
-      frontend = (this.frontends as Frontend[]).find((item) => item.name === options);
-      if (!frontend) {
-        throw new Error('找不到前端 ' + options);
+      frontendType = (this.frontendTypes as FrontendType[]).find((item) => item.name === options);
+      if (!frontendType) {
+        throw new Error('找不到端类型 ' + options);
       }
     } else {
-      frontend = options;
+      frontendType = options;
     }
-    return frontend.delete();
+    return frontendType.delete();
   }
 
-  __removeFrontend(frontend: Frontend) {
-    const parentKey = frontend.parentKey;
+  __removeFrontendType(frontendType: FrontendType) {
+    const parentKey = frontendType.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: frontend,
+      oldObject: frontendType,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = frontend.__v_raw || frontend;
+      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);
@@ -3948,7 +3941,14 @@ export class App extends BaseNode {
     return queryNodeByPath(this, nodePath);
   }
 
-  findNodeByCompleteName(completeName: string) {
+  findNodeByCompleteName(originCompleteName: string) {
+    let completeName = originCompleteName;
+    // 是否是来自编辑态的自定义连接器
+    const isFromEditableConnector = completeName.endsWith(CUSTOM_CONNECTOR_EDITABLE_SUFFIX);
+    if (isFromEditableConnector) {
+      // 为了查找到真实的结构，需要去掉编辑态的后缀
+      completeName = completeName.replace(CUSTOM_CONNECTOR_EDITABLE_SUFFIX, '');
+    }
     const nameArr = completeName?.split('.') || [];
     let node: any = this;
     // 先处理平台的
@@ -3967,7 +3967,11 @@ export class App extends BaseNode {
     const modules = modulesMap[start];
     if (Array.isArray(modules)) {
       const moduleName = nameArr.shift();
-      node = modules.find((moduleItem) => moduleItem.name === moduleName);
+      if(isFromEditableConnector) {
+        node = modules.find((moduleItem) => moduleItem.name === moduleName && moduleItem?.parentNode?.concept === 'Integration');
+      } else {
+        node = modules.find((moduleItem) => moduleItem.name === moduleName);
+      }
     }
     for (let index = 0; index < nameArr.length; index++) {
       if (!node) {
@@ -4066,10 +4070,10 @@ export class App extends BaseNode {
         names: [],
       },
     };
-    const frontends = this.frontends.filter((frontend) => frontend.type === scope);
+    const frontendTypes = this.frontendTypes.filter((frontendType) => frontendType.kind === scope);
     const existingSet = new Set();
-    frontends.forEach((frontend) => {
-      frontend.componentDependencies.forEach((dep) => {
+    frontendTypes.forEach((frontendType) => {
+      frontendType.componentDependencies.forEach((dep) => {
         const { name, version } = dep;
         const jsName = `${prefix}/packages/${name}@${version}/dist-theme/index.js`;
         if (!existingSet.has(jsName)) {
@@ -4176,7 +4180,11 @@ export class App extends BaseNode {
       structureCount: this.structures.length,
       enumCount: this.enums.length,
       logicCount: this.logics.length,
-      viewCount: sum(this.frontends.map((frontend) => countView(frontend.views))),
+      viewCount: sum(
+        this.frontendTypes.map((frontendType) =>
+          sum(frontendType.frontends.map((frontend) => countView(frontend.views))),
+        ),
+      ),
       processCount: this.processes.length,
     };
   }
@@ -4348,35 +4356,19 @@ export class App extends BaseNode {
     return errorList;
   }
 
-  addFrontendForType(options?: string | Partial<Frontend> | Frontend) {
-    let insertIndex = -1;
-    this.frontends.forEach((frontend, index) => {
-      if (frontend.type === (options as any).type) {
-        insertIndex = index;
-      }
-    });
-    if ((options as any).type === 'h5' && insertIndex === -1) {
-      insertIndex = this.frontends.length;
-    }
-    const node = this._insertFrontendAt(options as any, insertIndex + 1);
-    const index = this.frontends.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'frontends',
-    });
-    return node;
-  }
-
   getFrontendExistingTitles(excludedList: Array<Frontend> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.frontends as Frontend[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
+    return (this.frontendTypes || [])
+      .map((frontendType) => frontendType.frontends?.filter((item) => !excludedSet.has(item)).map((item) => item.title))
+      .flat(2);
   }
 
   getExtensionsCallbackLogics() {
     let resultLogics: string[] = [];
-    this.frontends.forEach((frontend) => {
-      resultLogics = [...resultLogics, ...frontend.getExtensionsCallbackLogics()];
+    this.frontendTypes.forEach((frontendType) => {
+      frontendType?.frontends?.forEach((frontend) => {
+        resultLogics = [...resultLogics, ...frontend.getExtensionsCallbackLogics()];
+      });
     });
     return Array.from(new Set(resultLogics));
   }
@@ -4390,7 +4382,6 @@ export class App extends BaseNode {
   }
 
   genAllCustomComponents() {
-    const { frontends } = this;
     const compMap: {
       pc: Array<any>;
       h5: Array<any>;
@@ -4399,12 +4390,12 @@ export class App extends BaseNode {
       h5: [],
     };
     const existingSet = new Set();
-    frontends.forEach((frontend) => {
-      if (frontend.componentDependencies) {
-        frontend.componentDependencies.forEach((dep) => {
+    this.frontendTypes.forEach((frontendType) => {
+      if (frontendType.componentDependencies) {
+        frontendType.componentDependencies.forEach((dep) => {
           const { name } = dep;
           if (!existingSet.has(name)) {
-            compMap[frontend.type].push(dep);
+            compMap[frontendType.kind].push(dep);
           }
         });
       }
@@ -4540,7 +4531,7 @@ export class App extends BaseNode {
         this,
         'interfaces',
       );
-    } else if (Assert.isInterface(options)) {
+    } else if (asserts.isInterface(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       itface = options;
       Object.assign(itface, relationOptions);
@@ -4686,7 +4677,7 @@ export class App extends BaseNode {
         this,
         'interfaces',
       );
-    } else if (Assert.isAuthInterface(options)) {
+    } else if (asserts.isAuthInterface(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       itface = options;
       Object.assign(itface, relationOptions);