@lcap/nasl 1.0.0-alpha.13 → 1.0.0-alpha.16

package/src/concepts/Namespace__.ts

@@ -200,7 +200,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'children');
         } else if (options instanceof Namespace) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             namespace = options;
             Object.assign(namespace, relationOptions);
         } else {
@@ -342,7 +342,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'processes');
         } else if (options instanceof Process) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             process = options;
             Object.assign(process, relationOptions);
         } else {
@@ -484,7 +484,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'entities');
         } else if (options instanceof Entity) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             entity = options;
             Object.assign(entity, relationOptions);
         } else {
@@ -626,7 +626,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'structures');
         } else if (options instanceof Structure) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             structure = options;
             Object.assign(structure, relationOptions);
         } else {
@@ -768,7 +768,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'enums');
         } else if (options instanceof Enum) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             enumeration = options;
             Object.assign(enumeration, relationOptions);
         } else {
@@ -910,7 +910,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'logics');
         } else if (options instanceof Logic) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logic = options;
             Object.assign(logic, relationOptions);
         } else {
@@ -1052,7 +1052,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'functions');
         } else if (options instanceof Function) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             func = options;
             Object.assign(func, relationOptions);
         } else {
@@ -1194,7 +1194,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'interfaces');
         } else if (options instanceof Interface) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             itface = options;
             Object.assign(itface, relationOptions);
         } else {
@@ -1336,7 +1336,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'views');
         } else if (options instanceof View) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             view = options;
             Object.assign(view, relationOptions);
         } else {
@@ -1478,7 +1478,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'variables');
         } else if (options instanceof Variable) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             variable = options;
             Object.assign(variable, relationOptions);
         } else {
@@ -1620,7 +1620,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'viewComponents');
         } else if (options instanceof ViewComponent) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             viewComponent = options;
             Object.assign(viewComponent, relationOptions);
         } else {
@@ -1762,7 +1762,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'processComponents');
         } else if (options instanceof ProcessComponent) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             processComponent = options;
             Object.assign(processComponent, relationOptions);
         } else {
@@ -2496,6 +2496,18 @@ export class Namespace extends BaseNode {
             throw new Error('无法获取命名空间，请设置 parentNode 或临时的 path！');
     }
 
+    /**
+     * 获取命名空间
+     */
+    getTsNamespace(): string {
+        if (this.path)
+            return this.path;
+        else if (this.parentNode && (this.parentNode as Namespace).getNamespace)
+            return `${(this.parentNode as Namespace).getNamespace()}.${this.tsName}`;
+        else
+            throw new Error('无法获取命名空间，请设置 parentNode 或临时的 path！');
+    }
+
     findChild(name: string) {
         return this.children.find((child) => child.name === name);
     }

package/src/concepts/Param__.ts

@@ -244,7 +244,7 @@ export class Param extends BaseNode {
     @excludedInJSON()
     @property()
     useComponent: {
-        type: 's-member-identifier-select' | 's-enum-select' | 's-schema-select' | 's-datatype-select' | 's-options-select';
+        type: 's-member-identifier-select' | 's-enum-select' | 's-schema-select' | 's-datatype-select' | 's-config-select' | 's-options-select';
         attrs?: any;
     } = undefined;
 
@@ -297,7 +297,7 @@ export class Param extends BaseNode {
                 // eslint-disable-next-line prefer-rest-params
                 throw new Error('找不到类型：' + arguments[0]);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
@@ -327,7 +327,7 @@ export class Param extends BaseNode {
         };
     }
 
-    _readonly: boolean = false
+    _readonly: boolean = false;
     /**
      * 是否可编辑
      * */
@@ -339,35 +339,46 @@ export class Param extends BaseNode {
         this._readonly = val;
     }
     get hasChildren() {
-        const { typeKind } = this.typeAnnotation;
+        const { typeKind, typeNamespace } = this.typeAnnotation;
         if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
             return [{}];
         }
         return null;
     }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        let completionChildren;
-        if (typeKind === 'reference') {
-            if (typeNamespace === 'nasl.ui') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                if (typeNamespace === 'nasl.collection') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
             } else {
-                const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
-            }
-        } else if (typeKind === 'generic') {
-            if (typeNamespace === 'nasl.collection') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
+                completionChildren = undefined;
             }
-        } else {
-            completionChildren = undefined;
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
         }
-        return completionChildren;
     }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

package/src/concepts/ProcessComponent__.ts

@@ -144,7 +144,7 @@ export class ProcessComponent extends BaseNode {
                 name: options,
             }, this, 'attrs');
         } else if (options instanceof Attribute) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             attribute = options;
             Object.assign(attribute, relationOptions);
         } else {
@@ -286,7 +286,7 @@ export class ProcessComponent extends BaseNode {
                 name: options,
             }, this, 'logics');
         } else if (options instanceof Logic) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logic = options;
             Object.assign(logic, relationOptions);
         } else {

package/src/concepts/ProcessElement__.ts

@@ -1,5 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
-import { constantToParam, genUserTaskLogic, returnToParam, getPreviousUserTask, syncMemberExpression } from '../server/getProcesses';
+import { constantToParam, genUserTaskLogic, returnToParam, getPreviousTask, syncMemberExpression } from '../server/getProcesses';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -292,7 +292,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'waypoints');
         } else if (options instanceof Point) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             point = options;
             Object.assign(point, relationOptions);
         } else {
@@ -434,7 +434,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'variables');
         } else if (options instanceof Variable) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             variable = options;
             Object.assign(variable, relationOptions);
         } else {
@@ -576,7 +576,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'returns');
         } else if (options instanceof Return) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             ret = options;
             Object.assign(ret, relationOptions);
         } else {
@@ -718,7 +718,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'constants');
         } else if (options instanceof Constant) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             constant = options;
             Object.assign(constant, relationOptions);
         } else {
@@ -860,7 +860,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'bindAttrs');
         } else if (options instanceof BindAttribute) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             bindAttribute = options;
             Object.assign(bindAttribute, relationOptions);
         } else {
@@ -1334,59 +1334,60 @@ export class ProcessElement extends BaseNode {
         const tab5 = indent(state.tabSize + 4);
         const tab6 = indent(state.tabSize + 5);
         let code = `${this.name}: {\n`;
-        this.variables.forEach(property => {
-            code += `${tab1}${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`
-        })
-        this.returns.forEach(property => {
-            code += `${tab1}${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`
-        })
-        this.constants.forEach(property => {
-            code += `${tab1}${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`
-        })
-
-        if(this.type === 'UserTask' || this.type === 'ExclusiveGateway') {
-            const prevUserTasks = getPreviousUserTask(this);
-            let prevCode = `${tab3}const ${this.process.name} = {\n`
+        this.variables.forEach((property) => {
+            code += `${tab1}${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
+        });
+        this.returns.forEach((property) => {
+            code += `${tab1}${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
+        });
+        this.constants.forEach((property) => {
+            code += `${tab1}${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
+        });
+
+        if (this.type === 'UserTask'
+            || this.type === 'ExclusiveGateway') {
+            const prevTasks = getPreviousTask(this);
+            let prevCode = `${tab3}const ${this.process.name} = {\n`;
             const processName = this.process.name;
-            this.process.params.forEach(p => {
-                prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`
-            })
-            this.process.returns.forEach(p => {
-                prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`
-            })
-            this.process.constants.forEach(p => {
-                prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`
-            })
+            this.process.params.forEach((p) => {
+                prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;
+            });
+            this.process.returns.forEach((p) => {
+                prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;
+            });
+            this.process.constants.forEach((p) => {
+                prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;
+            });
             // prevCode += `${tab4}elements: {\n`
-            prevCode += prevUserTasks.map(t => `${tab5}${t.name}: elements.${t.name},\n`).join(``);
-            
+            prevCode += prevTasks.map((t) => `${tab5}${t.name}: elements.${t.name},\n`).join(``);
+
             // prevCode += `${tab4}}\n`
-            
 
-            if(this.type === 'UserTask') {
-                prevCode += `\n${tab5}${this.name}: { \n${this.constants.map(c => `${tab6}${c.name}: "",` ).join('\n')} }\n`
+            if (this.type === 'UserTask') {
+                prevCode += `\n${tab5}${this.name}: { \n${this.constants.map((c) => `${tab6}${c.name}: "",`).join('\n')} }\n`;
                 prevCode += `${tab3}}\n`;
-                code += `${tab1}logics: {\n`
+                code += `${tab1}logics: {\n`;
                 this.bindAttrs.forEach((attr) => {
-                    if(attr.name === 'destination') {
+                    if (attr.name === 'destination') {
                         code += `${attr.destination.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode)},\n`;
                     }
-                });  
+                });
                 const logic = genUserTaskLogic(this);
+                // sourceMap 映射
+                logic.parentNode = this.process;
+
                 code += logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }));
-                code += ',\n'
+                code += ',\n';
                 code += `${tab1}}`;
             }
 
-            if(this.type === 'ExclusiveGateway') {
-                prevCode += `\n${tab5}${this.name}:  elements.${this.name},\n`
+            if (this.type === 'ExclusiveGateway') {
+                prevCode += `\n${tab5}${this.name}:  elements.${this.name},\n`;
                 prevCode += `${tab3}}\n`;
-                code += `${tab1}logic: ${this.logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode, true)},`
+                code += `${tab1}logic: ${this.logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode, true)},`;
             }
-
-            
         }
-        code += `${tab0}\n},\n`;
+        code += `${tab0}\n},`;
         // let code = '';
         // this.variables.forEach((property) => {
         //     code += `${tab0}export let `;
@@ -1450,19 +1451,19 @@ export default ProcessElement;
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
 //================================================================================
-ProcessElement.prototype.setName = function(name: string) {
+ProcessElement.prototype.setName = function (name: string) {
     const App = this.rootNode;
     const oldName = this.name;
     const processName = this.parentNode.name;
-    console.log(oldName);
+
     App.emit('collect:start', {
-        actionMsg: '设置名称'
+        actionMsg: '设置名称',
     });
     syncMemberExpression(this, (node) => {
-        if(node.object.name === processName && node.property.name === oldName) {
+        if (node.object.name === processName && node.property.name === oldName) {
             node.property.update({
                 name,
-            })
+            });
         }
     });
     const process = this.process;
@@ -1474,7 +1475,7 @@ ProcessElement.prototype.setName = function(name: string) {
             el.setTargetRef(name);
         }
     });
-    if(this.logic) {
+    if (this.logic) {
         this.logic.setName(name);
     }
     const object = {
@@ -1485,4 +1486,4 @@ ProcessElement.prototype.setName = function(name: string) {
         field: 'name',
     });
     App.emit('collect:end');
-}
+};

package/src/concepts/ProcessOutcome__.ts

@@ -74,7 +74,7 @@ export class ProcessOutcome extends LogicItem {
     //================================================================================
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        const code = `return () => ${this.flowRef ? this.flowRef : '__IDENTIFIER__'}`;
+        const code = `return () => ${this.flowRef ? `"${this.flowRef}"` : '__IDENTIFIER__'}`;
         return code;
     }
 

package/src/concepts/Process__.ts

@@ -194,7 +194,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'params');
         } else if (options instanceof Param) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             param = options;
             Object.assign(param, relationOptions);
         } else {
@@ -336,7 +336,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'returns');
         } else if (options instanceof Return) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             ret = options;
             Object.assign(ret, relationOptions);
         } else {
@@ -478,7 +478,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'constants');
         } else if (options instanceof Constant) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             constant = options;
             Object.assign(constant, relationOptions);
         } else {
@@ -620,7 +620,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'elements');
         } else if (options instanceof ProcessElement) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             element = options;
             Object.assign(element, relationOptions);
         } else {
@@ -986,18 +986,18 @@ export class Process extends BaseNode {
         // ];
         const ns = process2LogicNamespace(this);
         let logics: Logic[] = [];
-        ns.children.map(subns => {
-            logics = logics.concat(subns.logics)
-        })
+        ns.children.map((subns) => {
+            logics = logics.concat(subns.logics);
+        });
 
         return [
             ...ns.logics,
             ...logics,
-        ]
+        ];
     }
 
     toUserTaskPropertyGetterTS(userTask: ProcessElement) {
-        return `let ${userTask.name} = elements.${userTask.name};`
+        return `let ${userTask.name} = elements.${userTask.name};`;
     }
 
     @withSourceMap()
@@ -1027,18 +1027,21 @@ export class Process extends BaseNode {
         });
         code += `${tab1}export namespace logics {\n`;
         const logic = genLaunchProcess(this);
+        // sourceMap 映射
+        logic.parentNode = this;
         code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 2 }));
         code += `${tab1}}\n`;
-        
-        code += `${tab1}export const elements = {\n`
 
-        this.elements.forEach(ele => {
-            if(ele.type === 'UserTask' || ele.type === 'ExclusiveGateway') {
-                code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }))
+        code += `${tab1}export const elements = {\n`;
+
+        this.elements.forEach((ele) => {
+            code += '\n';
+            if (ele.type === 'UserTask' || ele.type === 'ExclusiveGateway' || ele.type === 'AutoTask') {
+                code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
             }
-        })
-        code += `${tab1}}\n`
-        code += `}\n`
+        });
+        code += `${tab1}}\n`;
+        code += `}\n`;
         return code;
     }
 
@@ -1081,8 +1084,8 @@ export class Process extends BaseNode {
                     type: 'StartNoneEvent',
                     bounds: {
                         concept: 'Rect',
-                        x: 0, y: 0
-                    }
+                        x: 0, y: 0,
+                    },
                 },
                 {
                     concept: 'ProcessElement',
@@ -1090,16 +1093,18 @@ export class Process extends BaseNode {
                     type: 'EndNoneEvent',
                     bounds: {
                         concept: 'Rect',
-                        x: 0, y: 180
-                    }
+                        x: 0, y: 180,
+                    },
                 },
                 {
                     concept: 'ProcessElement',
+                    name: 'SequenceFlow',
                     type: 'SequenceFlow',
                     sourceRef: 'Start',
                     targetRef: 'End',
+                    waypoints: [{ x: 0, y: 0 }, { x: 100, y: 100 }],
                 },
-            ]
+            ],
         };
     }
     //================================================================================
@@ -1114,18 +1119,17 @@ export default Process;
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
 //================================================================================
-Process.prototype.setName = function(name: string) {
+Process.prototype.setName = function (name: string) {
     const App = this.rootNode;
     const oldName = this.name;
-    console.log(oldName);
     App.emit('collect:start', {
-        actionMsg: '设置名称'
+        actionMsg: '设置名称',
     });
     syncMemberExpression(this, (node) => {
-        if(node.object instanceof Identifier &&  node.object.name === oldName) {
+        if (node.object instanceof Identifier && node.object.name === oldName) {
             node.object.update({
                 name,
-            })
+            });
         }
     });
     this.update({
@@ -1133,4 +1137,4 @@ Process.prototype.setName = function(name: string) {
         field: 'name',
     });
     App.emit('collect:end');
-}
+};

package/src/concepts/QueryAggregateExpression__.ts

@@ -138,7 +138,7 @@ export class QueryAggregateExpression extends LogicItem {
         //     code += `[__EMPTY_AGGREGATE_NAME__, '']`;
 
         // return code;
-        return `${this.asName || '__EMPTY_AGGREGATE_ALIAS__'}`;
+        return `__${this.asName || '__EMPTY_AGGREGATE_ALIAS__'}`;
     }
 
     setName(asName: string) {

package/src/concepts/QueryFromExpression__.ts

@@ -99,7 +99,7 @@ export class QueryFromExpression extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'joinParts' };
         let queryJoinExpression: QueryJoinExpression;
         if (options instanceof QueryJoinExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryJoinExpression = options;
             Object.assign(queryJoinExpression, relationOptions);
         } else {

package/src/concepts/QueryJoinExpression__.ts

@@ -132,7 +132,7 @@ export class QueryJoinExpression extends LogicItem {
                 name: options,
             }, this, 'onExpressions');
         } else if (options instanceof BinaryExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             binaryExpression = options;
             Object.assign(binaryExpression, relationOptions);
         } else {
@@ -250,7 +250,7 @@ export class QueryJoinExpression extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'joinParts' };
         let queryJoinExpression: QueryJoinExpression;
         if (options instanceof QueryJoinExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryJoinExpression = options;
             Object.assign(queryJoinExpression, relationOptions);
         } else {

package/src/concepts/QuerySelectExpression__.ts

@@ -113,7 +113,7 @@ export class QuerySelectExpression extends LogicItem {
                 name: options,
             }, this, 'selectElements');
         } else if (options instanceof QueryAggregateExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryAggregateExpression = options;
             Object.assign(queryAggregateExpression, relationOptions);
         } else {