@lcap/nasl 2.22.12-beta.1 → 2.22.12-beta.2

package/out/concepts/Connector__.js

@@ -36,74 +36,60 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Connector = void 0;
 const decorators_1 = require("../decorators");
 const utils = __importStar(require("../utils"));
-const Param__1 = __importDefault(require("./Param__"));
-const Logic__1 = __importDefault(require("./Logic__"));
-const ConnectorTrigger__1 = __importDefault(require("./ConnectorTrigger__"));
-const Structure__1 = __importDefault(require("./Structure__"));
-const Namespace__1 = __importDefault(require("./Namespace__"));
+const asserts = __importStar(require("./utils/asserts"));
 const Module__1 = __importDefault(require("./Module__"));
 /**
  * 连接器
  */
-let Connector = Connector_1 = 
-// @ts-ignore
-class Connector extends Module__1.default {
-    /** 类名 */
-    static ConceptName = 'Connector';
+let Connector = Connector_1 = class Connector extends Module__1.default {
     /**
-     * 产品概念
-     */
-    concept;
-    /**
-     * 连接器名称
-     */
-    // @ts-ignore
-    name;
-    /**
-     * connectorKind
-     */
-    // @ts-ignore
-    connectorKind;
-    /**
-     * 输入参数列表
-     */
-    properties = [];
-    /**
-     * 逻辑列表
-     */
-    logics = [];
-    /**
-     * 连接器触发器列表
-     */
-    triggers = [];
-    /**
-     * 数据结构列表
-     */
-    structures = [];
-    /**
-     * compilerInfoMap
-     */
-    // @ts-ignore
-    compilerInfoMap;
-    /**
-     * createLogic
-     */
-    // @ts-ignore
-    createLogic;
-    /**
-     * testConnectorLogic
-     */
-    // @ts-ignore
-    testConnectorLogic;
-    /**
-     * 预览图
-     */
-    // @ts-ignore
-    previewImg;
-    /**
-     * 命名空间列表
+     * @param source 需要合并的部分参数
      */
-    namespaces = [];
+    constructor(source) {
+        source = Object.assign({}, Connector_1.getDefaultOptions(), source);
+        super(source);
+        /**
+         * 输入参数列表
+         */
+        this.properties = [];
+        /**
+         * 逻辑列表
+         */
+        this.logics = [];
+        /**
+         * 连接器触发器列表
+         */
+        this.triggers = [];
+        /**
+         * 数据结构列表
+         */
+        this.structures = [];
+        /**
+         * 命名空间列表
+         */
+        this.namespaces = [];
+        /**
+         * 暴露接口的接口鉴权
+         */
+        this.authLogics = [];
+        /**
+         * 调用接口的鉴权模板
+         */
+        this.authLogicsForCallInterface = [];
+        /**
+         * 触发器启动器列表
+         */
+        this.triggerLaunchers = [];
+        /**
+         * 连接列表
+         */
+        this.connections = [];
+        /**
+         * isLocal
+         */
+        this.isLocal = true;
+        super.subConstructor(source);
+    }
     /**
      * 祖先 Module
      */
@@ -140,14 +126,6 @@ class Connector extends Module__1.default {
     get process() {
         return this.getAncestor('Process');
     }
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source) {
-        source = Object.assign({}, Connector_1.getDefaultOptions(), source);
-        super(source);
-        super.subConstructor(source);
-    }
     static from(source, parentNode, parentKey) {
         return super.from(source, parentNode, parentKey);
     }
@@ -273,6 +251,17 @@ class Connector extends Module__1.default {
             ...object,
         });
     }
+    /**
+     * 设置isLocal
+     */
+    setIsLocal(isLocal) {
+        const object = {
+            isLocal,
+        };
+        this.update({
+            ...object,
+        });
+    }
     getParamExistingNames(excludedList = []) {
         const excludedSet = new Set(excludedList);
         return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
@@ -283,26 +272,27 @@ class Connector extends Module__1.default {
     _insertParamAt(options, index) {
         const paramOptions = {};
         const relationOptions = { parentNode: this, parentKey: 'properties' };
+        const Param = (0, decorators_1.getConceptConstructor)('Param');
         let param;
         if (!options) {
-            param = Param__1.default.from({
+            param = Param.from({
                 ...paramOptions,
                 name: this.getParamUniqueName(),
             }, this, 'properties');
         }
         else if (typeof options === 'string') {
-            param = Param__1.default.from({
+            param = Param.from({
                 ...paramOptions,
                 name: options,
             }, this, 'properties');
         }
-        else if (options instanceof Param__1.default) {
+        else if (asserts.isParam(options)) {
             options.ensureDelete(); // 同一实例不支持多处存在
             param = options;
             Object.assign(param, relationOptions);
         }
         else {
-            param = Param__1.default.from({
+            param = Param.from({
                 ...paramOptions,
                 ...options,
             }, this, 'properties');
@@ -340,29 +330,30 @@ class Connector extends Module__1.default {
     getLogicUniqueName(name = 'logic1') {
         return utils.unique(name, this.getLogicExistingNames(), undefined, false);
     }
-    _insertLogicAt(options, index) {
+    _insertLogicInLogicsAt(options, index) {
         const logicOptions = {};
         const relationOptions = { parentNode: this, parentKey: 'logics' };
+        const Logic = (0, decorators_1.getConceptConstructor)('Logic');
         let logic;
         if (!options) {
-            logic = Logic__1.default.from({
+            logic = Logic.from({
                 ...logicOptions,
                 name: this.getLogicUniqueName(),
             }, this, 'logics');
         }
         else if (typeof options === 'string') {
-            logic = Logic__1.default.from({
+            logic = Logic.from({
                 ...logicOptions,
                 name: options,
             }, this, 'logics');
         }
-        else if (options instanceof Logic__1.default) {
+        else if (asserts.isLogic(options)) {
             options.ensureDelete(); // 同一实例不支持多处存在
             logic = options;
             Object.assign(logic, relationOptions);
         }
         else {
-            logic = Logic__1.default.from({
+            logic = Logic.from({
                 ...logicOptions,
                 ...options,
             }, this, 'logics');
@@ -370,8 +361,8 @@ class Connector extends Module__1.default {
         this.logics.splice(index, 0, logic);
         return logic;
     }
-    insertLogicAt(options, index) {
-        const node = this._insertLogicAt(options, index);
+    insertLogicInLogicsAt(options, index) {
+        const node = this._insertLogicInLogicsAt(options, index);
         node.create({
             index,
             parentNode: this,
@@ -379,12 +370,12 @@ class Connector extends Module__1.default {
         });
         return node;
     }
-    _addLogic(options) {
+    _addLogicInLogics(options) {
         const index = this.logics.length;
-        return this._insertLogicAt(options, index);
+        return this._insertLogicInLogicsAt(options, index);
     }
-    addLogic(options) {
-        const node = this._addLogic(options);
+    addLogicInLogics(options) {
+        const node = this._addLogicInLogics(options);
         const index = this.logics.indexOf(node);
         node.create({
             index,
@@ -405,26 +396,27 @@ class Connector extends Module__1.default {
     _insertConnectorTriggerAt(options, index) {
         const connectorTriggerOptions = {};
         const relationOptions = { parentNode: this, parentKey: 'triggers' };
+        const ConnectorTrigger = (0, decorators_1.getConceptConstructor)('ConnectorTrigger');
         let connectorTrigger;
         if (!options) {
-            connectorTrigger = ConnectorTrigger__1.default.from({
+            connectorTrigger = ConnectorTrigger.from({
                 ...connectorTriggerOptions,
                 name: this.getConnectorTriggerUniqueName(),
             }, this, 'triggers');
         }
         else if (typeof options === 'string') {
-            connectorTrigger = ConnectorTrigger__1.default.from({
+            connectorTrigger = ConnectorTrigger.from({
                 ...connectorTriggerOptions,
                 name: options,
             }, this, 'triggers');
         }
-        else if (options instanceof ConnectorTrigger__1.default) {
+        else if (asserts.isConnectorTrigger(options)) {
             options.ensureDelete(); // 同一实例不支持多处存在
             connectorTrigger = options;
             Object.assign(connectorTrigger, relationOptions);
         }
         else {
-            connectorTrigger = ConnectorTrigger__1.default.from({
+            connectorTrigger = ConnectorTrigger.from({
                 ...connectorTriggerOptions,
                 ...options,
             }, this, 'triggers');
@@ -465,26 +457,27 @@ class Connector extends Module__1.default {
     _insertStructureAt(options, index) {
         const structureOptions = {};
         const relationOptions = { parentNode: this, parentKey: 'structures' };
+        const Structure = (0, decorators_1.getConceptConstructor)('Structure');
         let structure;
         if (!options) {
-            structure = Structure__1.default.from({
+            structure = Structure.from({
                 ...structureOptions,
                 name: this.getStructureUniqueName(),
             }, this, 'structures');
         }
         else if (typeof options === 'string') {
-            structure = Structure__1.default.from({
+            structure = Structure.from({
                 ...structureOptions,
                 name: options,
             }, this, 'structures');
         }
-        else if (options instanceof Structure__1.default) {
+        else if (asserts.isStructure(options)) {
             options.ensureDelete(); // 同一实例不支持多处存在
             structure = options;
             Object.assign(structure, relationOptions);
         }
         else {
-            structure = Structure__1.default.from({
+            structure = Structure.from({
                 ...structureOptions,
                 ...options,
             }, this, 'structures');
@@ -525,26 +518,27 @@ class Connector extends Module__1.default {
     _insertNamespaceAt(options, index) {
         const namespaceOptions = {};
         const relationOptions = { parentNode: this, parentKey: 'namespaces' };
+        const Namespace = (0, decorators_1.getConceptConstructor)('Namespace');
         let namespace;
         if (!options) {
-            namespace = Namespace__1.default.from({
+            namespace = Namespace.from({
                 ...namespaceOptions,
                 name: this.getNamespaceUniqueName(),
             }, this, 'namespaces');
         }
         else if (typeof options === 'string') {
-            namespace = Namespace__1.default.from({
+            namespace = Namespace.from({
                 ...namespaceOptions,
                 name: options,
             }, this, 'namespaces');
         }
-        else if (options instanceof Namespace__1.default) {
+        else if (asserts.isNamespace(options)) {
             options.ensureDelete(); // 同一实例不支持多处存在
             namespace = options;
             Object.assign(namespace, relationOptions);
         }
         else {
-            namespace = Namespace__1.default.from({
+            namespace = Namespace.from({
                 ...namespaceOptions,
                 ...options,
             }, this, 'namespaces');
@@ -575,6 +569,132 @@ class Connector extends Module__1.default {
         });
         return node;
     }
+    getTriggerLauncherExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.triggerLaunchers || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item?.name);
+    }
+    getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
+        return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
+    }
+    _insertTriggerLauncherAt(options, index) {
+        const triggerLauncherOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
+        const TriggerLauncher = (0, decorators_1.getConceptConstructor)('TriggerLauncher');
+        let 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');
+        }
+        this.triggerLaunchers.splice(index, 0, triggerLauncher);
+        return triggerLauncher;
+    }
+    insertTriggerLauncherAt(options, index) {
+        const node = this._insertTriggerLauncherAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'triggerLaunchers',
+        });
+        return node;
+    }
+    _addTriggerLauncher(options) {
+        const index = 0;
+        return this._insertTriggerLauncherAt(options, index);
+    }
+    addTriggerLauncher(options) {
+        const node = this._addTriggerLauncher(options);
+        const index = this.triggerLaunchers.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'triggerLaunchers',
+        });
+        return node;
+    }
+    getConnectionExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.connections || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item?.name);
+    }
+    getConnectionUniqueName(name = 'connection1') {
+        return utils.unique(name, this.getConnectionExistingNames(), undefined, false);
+    }
+    _insertConnectionAt(options, index) {
+        const connectionOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'connections' };
+        const Connection = (0, decorators_1.getConceptConstructor)('Connection');
+        let connection;
+        if (!options) {
+            connection = Connection.from({
+                ...connectionOptions,
+                name: this.getConnectionUniqueName(),
+            }, this, 'connections');
+        }
+        else if (typeof options === 'string') {
+            connection = Connection.from({
+                ...connectionOptions,
+                name: options,
+            }, this, 'connections');
+        }
+        else if (asserts.isConnection(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            connection = options;
+            Object.assign(connection, relationOptions);
+        }
+        else {
+            connection = Connection.from({
+                ...connectionOptions,
+                ...options,
+            }, this, 'connections');
+        }
+        this.connections.splice(index, 0, connection);
+        return connection;
+    }
+    insertConnectionAt(options, index) {
+        const node = this._insertConnectionAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'connections',
+        });
+        return node;
+    }
+    _addConnection(options) {
+        const index = 0;
+        return this._insertConnectionAt(options, index);
+    }
+    addConnection(options) {
+        const node = this._addConnection(options);
+        const index = this.connections.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'connections',
+        });
+        return node;
+    }
     removeParam(options) {
         let param;
         if (typeof options === 'string') {
@@ -609,9 +729,12 @@ class Connector extends Module__1.default {
                 ~index && this[parentKey].splice(index, 1);
                 params.index = index;
             }
-            else if (t[parentKey] === n) {
-                params.index = 0;
-                this[parentKey] = undefined;
+            else {
+                const q = t[parentKey];
+                if ((q.__v_raw || q) === n) {
+                    params.index = 0;
+                    this[parentKey] = undefined;
+                }
             }
         }
         return params;
@@ -655,6 +778,32 @@ class Connector extends Module__1.default {
         }
         return testConnectorLogic.delete();
     }
+    removeAuthLogicInAuthLogics(options) {
+        let authLogic;
+        if (typeof options === 'string') {
+            authLogic = this.authLogics.find((item) => item.name === options);
+            if (!authLogic) {
+                throw new Error('找不到鉴权逻辑 ' + options);
+            }
+        }
+        else {
+            authLogic = options;
+        }
+        return authLogic.delete();
+    }
+    removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(options) {
+        let authLogicForCallInterface;
+        if (typeof options === 'string') {
+            authLogicForCallInterface = this.authLogicsForCallInterface.find((item) => item.name === options);
+            if (!authLogicForCallInterface) {
+                throw new Error('找不到调用接口的鉴权逻辑 ' + options);
+            }
+        }
+        else {
+            authLogicForCallInterface = options;
+        }
+        return authLogicForCallInterface.delete();
+    }
     __removeLogic(logic) {
         const parentKey = logic.parentKey;
         const params = {
@@ -676,9 +825,12 @@ class Connector extends Module__1.default {
                 ~index && this[parentKey].splice(index, 1);
                 params.index = index;
             }
-            else if (t[parentKey] === n) {
-                params.index = 0;
-                this[parentKey] = undefined;
+            else {
+                const q = t[parentKey];
+                if ((q.__v_raw || q) === n) {
+                    params.index = 0;
+                    this[parentKey] = undefined;
+                }
             }
         }
         return params;
@@ -717,9 +869,12 @@ class Connector extends Module__1.default {
                 ~index && this[parentKey].splice(index, 1);
                 params.index = index;
             }
-            else if (t[parentKey] === n) {
-                params.index = 0;
-                this[parentKey] = undefined;
+            else {
+                const q = t[parentKey];
+                if ((q.__v_raw || q) === n) {
+                    params.index = 0;
+                    this[parentKey] = undefined;
+                }
             }
         }
         return params;
@@ -758,9 +913,12 @@ class Connector extends Module__1.default {
                 ~index && this[parentKey].splice(index, 1);
                 params.index = index;
             }
-            else if (t[parentKey] === n) {
-                params.index = 0;
-                this[parentKey] = undefined;
+            else {
+                const q = t[parentKey];
+                if ((q.__v_raw || q) === n) {
+                    params.index = 0;
+                    this[parentKey] = undefined;
+                }
             }
         }
         return params;
@@ -799,9 +957,100 @@ class Connector extends Module__1.default {
                 ~index && this[parentKey].splice(index, 1);
                 params.index = index;
             }
-            else if (t[parentKey] === n) {
-                params.index = 0;
-                this[parentKey] = undefined;
+            else {
+                const q = t[parentKey];
+                if ((q.__v_raw || q) === n) {
+                    params.index = 0;
+                    this[parentKey] = undefined;
+                }
+            }
+        }
+        return params;
+    }
+    removeTriggerLauncher(options) {
+        let triggerLauncher;
+        if (typeof options === 'string') {
+            triggerLauncher = this.triggerLaunchers.find((item) => item.name === options);
+            if (!triggerLauncher) {
+                throw new Error('找不到触发器启动器 ' + options);
+            }
+        }
+        else {
+            triggerLauncher = options;
+        }
+        return triggerLauncher.delete();
+    }
+    __removeTriggerLauncher(triggerLauncher) {
+        const parentKey = triggerLauncher.parentKey;
+        const 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[parentKey])) {
+                // @ts-ignore
+                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else {
+                const q = t[parentKey];
+                if ((q.__v_raw || q) === n) {
+                    params.index = 0;
+                    this[parentKey] = undefined;
+                }
+            }
+        }
+        return params;
+    }
+    removeConnection(options) {
+        let connection;
+        if (typeof options === 'string') {
+            connection = this.connections.find((item) => item.name === options);
+            if (!connection) {
+                throw new Error('找不到连接 ' + options);
+            }
+        }
+        else {
+            connection = options;
+        }
+        return connection.delete();
+    }
+    __removeConnection(connection) {
+        const parentKey = connection.parentKey;
+        const 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[parentKey])) {
+                // @ts-ignore
+                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else {
+                const q = t[parentKey];
+                if ((q.__v_raw || q) === n) {
+                    params.index = 0;
+                    this[parentKey] = undefined;
+                }
             }
         }
         return params;
@@ -832,7 +1081,165 @@ class Connector extends Module__1.default {
     getNamespaceUniqueTitle(name = '分组1') {
         return utils.unique(name, this.getNamespaceExistingTitles(), undefined, false);
     }
+    // ================  为解决循环引用而将之前的自动生成代码移动到这里  START =================
+    getAuthLogicForCallInterfaceExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.authLogicsForCallInterface || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getAuthLogicForCallInterfaceUniqueName(name = 'authLogicForCallInterface1') {
+        return utils.unique(name, this.getAuthLogicForCallInterfaceExistingNames(), undefined, false);
+    }
+    _insertAuthLogicForCallInterfaceAt(options, index) {
+        const authLogicForCallInterfaceOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
+        let authLogicForCallInterface;
+        if (!options) {
+            throw Error('请先调用from方法创建AuthLogicForCallInterface实例');
+        }
+        else if (typeof options === 'string') {
+            throw Error('请先调用from方法创建AuthLogicForCallInterface实例');
+            // FIXME : dont change
+        }
+        else if (options.concept === 'AuthLogicForCallInterface') {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogicForCallInterface = options;
+            Object.assign(authLogicForCallInterface, relationOptions);
+        }
+        else {
+            throw Error('请先调用from方法创建AuthLogicForCallInterface实例');
+        }
+        this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
+        return authLogicForCallInterface;
+    }
+    insertAuthLogicForCallInterfaceAt(options, index) {
+        const node = this._insertAuthLogicForCallInterfaceAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogicsForCallInterface',
+        });
+        return node;
+    }
+    _addAuthLogicForCallInterface(options) {
+        const index = this.authLogicsForCallInterface.length;
+        return this._insertAuthLogicForCallInterfaceAt(options, index);
+    }
+    addAuthLogicForCallInterface(options) {
+        const node = this._addAuthLogicForCallInterface(options);
+        const index = this.authLogicsForCallInterface.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogicsForCallInterface',
+        });
+        return node;
+    }
+    removeAuthLogicForCallInterface(options) {
+        let authLogicForCallInterface;
+        if (typeof options === 'string') {
+            authLogicForCallInterface = this.authLogicsForCallInterface.find((item) => item.name === options);
+            if (!authLogicForCallInterface) {
+                throw new Error('找不到调用接口的鉴权逻辑 ' + options);
+            }
+        }
+        else {
+            authLogicForCallInterface = options;
+        }
+        return authLogicForCallInterface.delete();
+    }
+    __removeAuthLogic(authLogic) {
+        const parentKey = authLogic.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: authLogic,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(authLogic);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === authLogic) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    _insertAuthLogicInAuthLogicsAt(options, index) {
+        const relationOptions = { parentNode: this, parentKey: 'authLogics' };
+        let authLogic;
+        if (!options) {
+            // authLogic = AuthLogic.from({
+            //     ...authLogicOptions,
+            //     name: this.getAuthLogicUniqueName(),
+            // }, this, 'authLogics');
+            throw Error('请先调用from方法');
+        }
+        else if (typeof options === 'string') {
+            // authLogic = AuthLogic.from({
+            //     ...authLogicOptions,
+            //     name: options,
+            // }, this, 'authLogics');
+            // FIXME : dont change
+            throw Error('请先调用from方法');
+        }
+        else if (options.concept === 'AuthLogic') {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogic = options;
+            Object.assign(authLogic, relationOptions);
+        }
+        else {
+            // authLogic = AuthLogic.from({
+            //     ...authLogicOptions,
+            //     ...options,
+            // }, this, 'authLogics');
+            throw Error('请先调用from方法');
+        }
+        this.authLogics.splice(index, 0, authLogic);
+        return authLogic;
+    }
+    insertAuthLogicInAuthLogicsAt(options, index) {
+        const node = this._insertAuthLogicInAuthLogicsAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogics',
+        });
+        return node;
+    }
+    _addAuthLogicInAuthLogics(options) {
+        const index = this.authLogics.length;
+        return this._insertAuthLogicInAuthLogicsAt(options, index);
+    }
+    addAuthLogicInAuthLogics(options) {
+        const node = this._addAuthLogicInAuthLogics(options);
+        const index = this.authLogics.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogics',
+        });
+        return node;
+    }
+    getAuthLogicExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.authLogics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getAuthLogicUniqueName(name = 'authentication1') {
+        return utils.unique(name, this.getAuthLogicExistingNames(), undefined, true);
+    }
 };
+/** 类名 */
+Connector.ConceptName = 'Connector';
+/** 继承链 */
+Connector.inheritanceChain = ['Module', 'BaseNode'];
 __decorate([
     (0, decorators_1.property)('concept')
 ], Connector.prototype, "concept", void 0);
@@ -843,36 +1250,89 @@ __decorate([
     (0, decorators_1.property)()
 ], Connector.prototype, "connectorKind", void 0);
 __decorate([
-    (0, decorators_1.property)('Param')
+    (0, decorators_1.property)({
+        objectRef: 'Param',
+        isArray: true,
+        defaultValue: [],
+    })
 ], Connector.prototype, "properties", void 0);
 __decorate([
-    (0, decorators_1.property)('Logic')
+    (0, decorators_1.property)({
+        objectRef: 'Logic',
+        isArray: true,
+        defaultValue: [],
+    })
 ], Connector.prototype, "logics", void 0);
 __decorate([
-    (0, decorators_1.property)('ConnectorTrigger')
+    (0, decorators_1.property)({
+        objectRef: 'ConnectorTrigger',
+        isArray: true,
+        defaultValue: [],
+    })
 ], Connector.prototype, "triggers", void 0);
 __decorate([
-    (0, decorators_1.property)('Structure')
+    (0, decorators_1.property)({
+        objectRef: 'Structure',
+        isArray: true,
+        defaultValue: [],
+    })
 ], Connector.prototype, "structures", void 0);
 __decorate([
     (0, decorators_1.property)()
 ], Connector.prototype, "compilerInfoMap", void 0);
 __decorate([
-    (0, decorators_1.property)('Logic')
+    (0, decorators_1.property)({
+        objectRef: 'Logic',
+    })
 ], Connector.prototype, "createLogic", void 0);
 __decorate([
-    (0, decorators_1.property)('Logic')
+    (0, decorators_1.property)({
+        objectRef: 'Logic',
+    })
 ], Connector.prototype, "testConnectorLogic", void 0);
 __decorate([
     (0, decorators_1.property)()
 ], Connector.prototype, "previewImg", void 0);
 __decorate([
-    (0, decorators_1.property)('Namespace')
+    (0, decorators_1.property)({
+        objectRef: 'Namespace',
+        isArray: true,
+        defaultValue: [],
+    })
 ], Connector.prototype, "namespaces", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'AuthLogic',
+        isArray: true,
+        defaultValue: [],
+    })
+], Connector.prototype, "authLogics", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'AuthLogicForCallInterface',
+        isArray: true,
+        defaultValue: [],
+    })
+], Connector.prototype, "authLogicsForCallInterface", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'TriggerLauncher',
+        isArray: true,
+        defaultValue: [],
+    })
+], Connector.prototype, "triggerLaunchers", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Connection',
+        isArray: true,
+        defaultValue: [],
+    })
+], Connector.prototype, "connections", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Connector.prototype, "isLocal", void 0);
 Connector = Connector_1 = __decorate([
-    decorators_1.className,
     (0, decorators_1.concept)('连接器')
-    // @ts-ignore
 ], Connector);
 exports.Connector = Connector;
 exports.default = Connector;