@lcap/nasl 1.0.0-alpha.9 → 1.0.0

package/src/concepts/ProcessElement__.ts

@@ -1,5 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
-import { constantToParam, genUserTaskLogic, returnToParam } 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 {
@@ -380,7 +380,7 @@ export class ProcessElement extends BaseNode {
 
     addPoint(options?: string | Partial<Point> | Point) {
         const node = this._addPoint(options as any);
-        const index = this.waypoints.length;
+        const index = this.waypoints.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -522,7 +522,7 @@ export class ProcessElement extends BaseNode {
 
     addVariable(options?: string | Partial<Variable> | Variable) {
         const node = this._addVariable(options as any);
-        const index = this.variables.length;
+        const index = this.variables.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -664,7 +664,7 @@ export class ProcessElement extends BaseNode {
 
     addReturn(options?: string | Partial<Return> | Return) {
         const node = this._addReturn(options as any);
-        const index = this.returns.length;
+        const index = this.returns.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -806,7 +806,7 @@ export class ProcessElement extends BaseNode {
 
     addConstant(options?: string | Partial<Constant> | Constant) {
         const node = this._addConstant(options as any);
-        const index = this.constants.length;
+        const index = this.constants.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -948,7 +948,7 @@ export class ProcessElement extends BaseNode {
 
     addBindAttribute(options?: string | Partial<BindAttribute> | BindAttribute) {
         const node = this._addBindAttribute(options as any);
-        const index = this.bindAttrs.length;
+        const index = this.bindAttrs.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -1328,23 +1328,86 @@ export class ProcessElement extends BaseNode {
     toEmbeddedTS(state?: TranslatorState): string {
         // this.syncLogic();
         const tab0 = indent(state.tabSize);
-        let code = '';
+        const tab1 = indent(state.tabSize + 1);
+        const tab3 = indent(state.tabSize + 2);
+        const tab4 = indent(state.tabSize + 3);
+        const tab5 = indent(state.tabSize + 4);
+        const tab6 = indent(state.tabSize + 5);
+        let code = `${this.name}: {\n`;
         this.variables.forEach((property) => {
-            code += `${tab0}let `;
-            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += ';\n';
+            code += `${tab1}`;
+            code += `${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
         });
-
         this.returns.forEach((property) => {
-            code += `${tab0}let `;
-            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += ';\n';
+            code += `${tab1}`;
+            code += `${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
         });
         this.constants.forEach((property) => {
-            code += `${tab0}export let `;
-            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += ';\n';
+            code += `${tab1}`;
+            code += `${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`;
+            });
+            // prevCode += `${tab4}elements: {\n`
+            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`;
+                prevCode += `${tab3}}\n`;
+                code += `${tab1}logics: {\n`;
+                this.bindAttrs.forEach((attr) => {
+                    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 += `${tab1}}`;
+            }
+
+            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 += `${tab0}\n},`;
+        // let code = '';
+        // this.variables.forEach((property) => {
+        //     code += `${tab0}export let `;
+        //     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        //     code += ';\n';
+        // });
+
+        // this.returns.forEach((property) => {
+        //     code += `${tab0}export let `;
+        //     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        //     code += ';\n';
+        // });
+        // this.constants.forEach((property) => {
+        //     code += `${tab0}export let `;
+        //     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        //     code += ';\n';
+        // });
         return code;
     }
 
@@ -1362,23 +1425,23 @@ export class ProcessElement extends BaseNode {
     /**
      * 设置流程元素名称
      */
-    setNameWithFlowChange(name: string) {
-        this.app.emit('collect:start', {
-            actionMsg: '设置流程元素名称',
-        });
-        const oldName = this.name;
-        this.setName(name);
-        const process = this.process;
-        process.elements.forEach((el) => {
-            if (el.sourceRef === oldName) {
-                el.setSourceRef(name);
-            }
-            if (el.targetRef === oldName) {
-                el.setTargetRef(name);
-            }
-        });
-        this.app.emit('collect:end');
-    }
+    // setNameWithFlowChange(name: string) {
+    //     this.app.emit('collect:start', {
+    //         actionMsg: '设置流程元素名称',
+    //     });
+    //     const oldName = this.name;
+    //     this.setName(name);
+    //     const process = this.process;
+    //     process.elements.forEach((el) => {
+    //         if (el.sourceRef === oldName) {
+    //             el.setSourceRef(name);
+    //         }
+    //         if (el.targetRef === oldName) {
+    //             el.setTargetRef(name);
+    //         }
+    //     });
+    //     this.app.emit('collect:end');
+    // }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1391,3 +1454,39 @@ export default ProcessElement;
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
 //================================================================================
+ProcessElement.prototype.setName = function (name: string) {
+    const App = this.rootNode;
+    const oldName = this.name;
+    const processName = this.parentNode.name;
+
+    App.emit('collect:start', {
+        actionMsg: '设置名称',
+    });
+    const object = {
+        name,
+    };
+    this.update({
+        ...object,
+        field: 'name',
+    });
+    syncMemberExpression(this, (node) => {
+        if (node.object.name === processName && node.property.name === oldName) {
+            node.property.update({
+                name,
+            });
+        }
+    });
+    const process = this.process;
+    process.elements.forEach((el) => {
+        if (el.sourceRef === oldName) {
+            el.setSourceRef(name);
+        }
+        if (el.targetRef === oldName) {
+            el.setTargetRef(name);
+        }
+    });
+    if (this.logic) {
+        this.logic.setName(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}"`}`;
+        const code = `return () => ${this.flowRef ? `"${this.flowRef}"` : '__IDENTIFIER__'}`;
         return code;
     }
 

package/src/concepts/Process__.ts

@@ -1,9 +1,10 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
-import { process2LogicNamespace, genLaunchProcess, genUserTaskLogic, userTask2LogicNamespace } from '../server/getProcesses';
-
+import { genLaunchProcess, genUserTaskLogic, userTask2LogicNamespace, syncMemberExpression } from '../server/getProcesses';
+import { process2LogicNamespace } from '../server/process2LogicNamespace';
 import Namespace from './Namespace__';
 import Logic from './Logic__';
 import Variable from './Variable__';
+import Identifier from './Identifier__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -193,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 {
@@ -281,7 +282,7 @@ export class Process extends BaseNode {
 
     addParam(options?: string | Partial<Param> | Param) {
         const node = this._addParam(options as any);
-        const index = this.params.length;
+        const index = this.params.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -335,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 {
@@ -423,7 +424,7 @@ export class Process extends BaseNode {
 
     addReturn(options?: string | Partial<Return> | Return) {
         const node = this._addReturn(options as any);
-        const index = this.returns.length;
+        const index = this.returns.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -477,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 {
@@ -565,7 +566,7 @@ export class Process extends BaseNode {
 
     addConstant(options?: string | Partial<Constant> | Constant) {
         const node = this._addConstant(options as any);
-        const index = this.constants.length;
+        const index = this.constants.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -619,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 {
@@ -707,7 +708,7 @@ export class Process extends BaseNode {
 
     addElement(options?: string | Partial<ProcessElement> | ProcessElement) {
         const node = this._addElement(options as any);
-        const index = this.elements.length;
+        const index = this.elements.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -974,7 +975,29 @@ export class Process extends BaseNode {
     }
 
     get logics() {
-        return [genLaunchProcess(this)];
+        // return [
+        //     genLaunchProcess(this),
+        //     ...this.elements.filter(el => el.type === 'UserTask').map(el => {
+        //         return {
+        //             name: el.name,
+        //             complete: genUserTaskLogic(el),
+        //         }
+        //     })
+        // ];
+        const ns = process2LogicNamespace(this);
+        let logics: Logic[] = [];
+        ns.children.map((subns) => {
+            logics = logics.concat(subns.logics);
+        });
+
+        return [
+            ...ns.logics,
+            ...logics,
+        ];
+    }
+
+    toUserTaskPropertyGetterTS(userTask: ProcessElement) {
+        return `let ${userTask.name} = elements.${userTask.name};`;
     }
 
     @withSourceMap()
@@ -985,6 +1008,14 @@ export class Process extends BaseNode {
         const tab2 = indent(state.tabSize + 2);
         const tab3 = indent(state.tabSize + 3);
         // code += `${tab1}namespace variables{\n`;
+
+        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`;
+
         this.params.forEach((property) => {
             code += `${tab1}export let `;
             code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
@@ -1002,63 +1033,16 @@ export class Process extends BaseNode {
             code += ';\n';
         });
 
+        code += `${tab1}export const elements = {\n`;
 
-        // code += `${tab1}}\n`;
-
-        // this.elements.forEach((ele) => {
-        //     if (ele.type === 'UserTask') {
-        //         code += `${tab1}${ele.name}: nasl.process.UserTask;\n`;
-        //     }
-        // });
-
-        // code += `${tab1}constructor(`;
-        // this.params.forEach((param, index) => {
-        //     code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        //     if (index !== this.params.length - 1)
-        //         code += ', ';
-        // });
-        // code += `) {\n`;
-
-        code += `${tab1}export namespace logics {\n`;
-        const logic = genLaunchProcess(this);
-        code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 3 }));
-        code += `${tab1}}\n`;
-
-        code += `${tab1}export namespace elements {\n`
         this.elements.forEach((ele) => {
-            if (ele.type === 'UserTask') {
-                code += `${tab2}export namespace ${ele.name}{\n`;
+            code += '\n';
+            if (ele.type === 'UserTask' || ele.type === 'ExclusiveGateway' || ele.type === 'AutoTask') {
                 code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
-                ele.bindAttrs.forEach((attr) => {
-                    if(attr.name === 'destination') {
-                        code += attr.destination.toEmbeddedTSNormalFunction(shiftState(state, code, { tabSize: state.tabSize + 2 }))
-                    } else {
-                        code += attr.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize }));
-                    }
-                });
-
-                const logic = genUserTaskLogic(ele);
-                code += `${tab3}export namespace logics {\n`;
-
-                code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 4 }));
-
-                code += `${tab3}}\n`;
-
-                code += `${tab2}}\n`;
-
-                
-            }
-            if (ele.type === 'ExclusiveGateway') {
-                code += `${tab2}export namespace ${ele.name}{\n`;
-                code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
-                code += ele.logic.toEmbeddedTSNoExport(shiftState(state, code, { tabSize: state.tabSize + 3 }));
-                code += `${tab2}}\n`;
             }
         });
         code += `${tab1}}\n`;
-
-        // code += `${tab1}}\n`;
-        code += `${tab0}}\n`;
+        code += `}\n`;
         return code;
     }
 
@@ -1066,31 +1050,13 @@ export class Process extends BaseNode {
         let code = `namespace ${this.getNamespace('processes')} {\n`;
 
         const state = createCompilerState(code, { tabSize: 1 });
-        const tab1 = indent(state.tabSize);
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
-        /* const ns = process2LogicNamespace(this);
-        ns.path = `${this.getNamespace('logics')}.${ns.name}`;
-        code += `\nnamespace ${ns.path} {\n`;
-        ns.logics.forEach((logic) => {
-            code += logic.toEmbeddedTS(shiftState(state, code)) + '\n';
-        });
-        this.elements.forEach((ele) => {
-            if (ele.type === 'UserTask') {
-                const uns = userTask2LogicNamespace(ele);
-                code += `${tab1}export namespace ${uns.name} {\n`;
-
-                uns.logics.forEach((logic) => {
-                    code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
-                });
-
-                code += `${tab1}}\n`;
-            }
-        });
-
-        code += '}\n';*/
-
         return {
             code,
             filePath: this.getEmbeddedFilePath(),
@@ -1115,29 +1081,31 @@ export class Process extends BaseNode {
             elements: [
                 {
                     concept: 'ProcessElement',
-                    name: 'start',
+                    name: 'Start',
                     type: 'StartNoneEvent',
                     bounds: {
                         concept: 'Rect',
-                        x: 0, y: 0
-                    }
+                        x: 0, y: 0,
+                    },
                 },
                 {
                     concept: 'ProcessElement',
-                    name: 'end',
+                    name: 'End',
                     type: 'EndNoneEvent',
                     bounds: {
                         concept: 'Rect',
-                        x: 0, y: 180
-                    }
+                        x: 0, y: 180,
+                    },
                 },
                 {
                     concept: 'ProcessElement',
+                    name: 'SequenceFlow',
                     type: 'SequenceFlow',
-                    sourceRef: 'start',
-                    targetRef: 'end',
+                    sourceRef: 'Start',
+                    targetRef: 'End',
+                    waypoints: [{ x: 0, y: 0 }, { x: 100, y: 100 }],
                 },
-            ]
+            ],
         };
     }
     //================================================================================
@@ -1152,3 +1120,22 @@ export default Process;
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
 //================================================================================
+Process.prototype.setName = function (name: string) {
+    const App = this.rootNode;
+    const oldName = this.name;
+    App.emit('collect:start', {
+        actionMsg: '设置名称',
+    });
+    syncMemberExpression(this, (node) => {
+        if (node.object instanceof Identifier && node.object.name === oldName) {
+            node.object.update({
+                name,
+            });
+        }
+    });
+    this.update({
+        name,
+        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 {
@@ -173,7 +173,7 @@ export class QueryFromExpression extends LogicItem {
 
     addJoinPart(options?: Partial<QueryJoinExpression> | QueryJoinExpression) {
         const node = this._addJoinPart(options as any);
-        const index = this.joinParts.length;
+        const index = this.joinParts.indexOf(node);
         node.create({
             index,
             parentNode: this,

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 {
@@ -220,7 +220,7 @@ export class QueryJoinExpression extends LogicItem {
 
     addBinaryExpressionInOnExpressions(options?: string | Partial<BinaryExpression> | BinaryExpression) {
         const node = this._addBinaryExpressionInOnExpressions(options as any);
-        const index = this.onExpressions.length;
+        const index = this.onExpressions.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -324,7 +324,7 @@ export class QueryJoinExpression extends LogicItem {
 
     addJoinPartInJoinParts(options?: Partial<QueryJoinExpression> | QueryJoinExpression) {
         const node = this._addJoinPartInJoinParts(options as any);
-        const index = this.joinParts.length;
+        const index = this.joinParts.indexOf(node);
         node.create({
             index,
             parentNode: this,