@nocobase/plugin-workflow 2.2.0-beta.1 → 2.2.0-beta.11

package/dist/server/Dispatcher.js

@@ -35,6 +35,7 @@ var import_constants = require("./constants");
 var import_Plugin = require("./Plugin");
 var import_utils = require("./utils");
 const EXECUTION_ACQUIRE_MAX_ATTEMPTS = 5;
+const PENDING_DISPATCH_MAX_ATTEMPTS = 3;
 class Dispatcher {
   constructor(plugin) {
     this.plugin = plugin;
@@ -53,7 +54,7 @@ class Dispatcher {
     const execution = await ExecutionRepo.findOne({
       filterByTk: event.executionId
     });
-    if (!execution || execution.dispatched) {
+    if (!execution || execution.dispatched || execution.status !== import_constants.EXECUTION_STATUS.QUEUEING) {
       return;
     }
     this.plugin.getLogger(execution.workflowId).info(`execution (${execution.id}) received from queue, adding to pending list`);
@@ -70,7 +71,7 @@ class Dispatcher {
     if (!this.ready) {
       logger.warn(`app is not ready, event of workflow ${workflow.id} will be ignored`);
       logger.debug(`ignored event data:`, context);
-      return;
+      return this.handleTriggerFail(workflow, context, options, new Error("app is not ready"));
     }
     if (!options.force && !options.manually && !workflow.enabled) {
       logger.warn(`workflow ${workflow.id} is not enabled, event will be ignored`);
@@ -87,7 +88,7 @@ class Dispatcher {
     }
     if (context == null) {
       logger.warn(`workflow ${workflow.id} event data context is null, event will be ignored`);
-      return;
+      return this.handleTriggerFail(workflow, context, options, new Error("event context is null"));
     }
     if (options.manually || this.plugin.isWorkflowSync(workflow)) {
       return this.triggerSync(workflow, context, options);
@@ -196,39 +197,56 @@ class Dispatcher {
     }
     this.executing = (async () => {
       let next = null;
-      const pending = this.pending.shift() ?? null;
-      if (pending || this.ready && this.plugin.serving()) {
-        const execution = await this.prepare((pending == null ? void 0 : pending.execution) ?? null, {
-          immediate: pending == null ? void 0 : pending.immediate
-        });
-        if (execution) {
-          next = [execution, pending == null ? void 0 : pending.job, pending == null ? void 0 : pending.rerun];
+      let pending = null;
+      try {
+        pending = this.pending.shift() ?? null;
+        if (pending || this.ready && this.plugin.serving()) {
+          const execution = await this.prepare((pending == null ? void 0 : pending.execution) ?? null, {
+            immediate: pending == null ? void 0 : pending.immediate
+          });
+          if (execution) {
+            next = [execution, pending == null ? void 0 : pending.job, pending == null ? void 0 : pending.rerun];
+          }
+          if (pending && next) {
+            this.plugin.getLogger(next[0].workflowId).info(`pending execution (${next[0].id}) ready to process`);
+          }
+        } else {
+          this.plugin.getLogger("dispatcher").warn(
+            `${import_Plugin.WORKER_JOB_WORKFLOW_PROCESS} is not serving on this instance or app not ready, new dispatching will be ignored`
+          );
         }
-        if (pending && next) {
-          this.plugin.getLogger(next[0].workflowId).info(`pending execution (${next[0].id}) ready to process`);
+        if (next) {
+          try {
+            await this.process(next[0], next[1], { rerun: next[2] });
+          } catch (error) {
+            this.plugin.getLogger(next[0].workflowId).error(`execution (${next[0].id}) process failed`, { error });
+            if (pending && (0, import_utils.isLockAcquireError)(error)) {
+              this.pending.unshift({ ...pending, execution: next[0], immediate: true });
+            }
+          }
         }
-      } else {
-        this.plugin.getLogger("dispatcher").warn(
-          `${import_Plugin.WORKER_JOB_WORKFLOW_PROCESS} is not serving on this instance or app not ready, new dispatching will be ignored`
-        );
-      }
-      if (next) {
-        try {
-          await this.process(next[0], next[1], { rerun: next[2] });
-        } catch (error) {
-          this.plugin.getLogger(next[0].workflowId).error(`execution (${next[0].id}) process failed`, { error });
-          if (pending && (0, import_utils.isLockAcquireError)(error)) {
-            this.pending.unshift({ ...pending, execution: next[0], immediate: true });
+      } catch (error) {
+        this.plugin.getLogger("dispatcher").error(`workflow dispatch failed`, { error });
+        if (pending) {
+          const dispatchAttempts = (pending.dispatchAttempts ?? 0) + 1;
+          if (dispatchAttempts < PENDING_DISPATCH_MAX_ATTEMPTS) {
+            this.pending.push({ ...pending, dispatchAttempts });
+          } else {
+            this.plugin.getLogger(pending.execution.workflowId).error(`pending execution (${pending.execution.id}) dispatch failed, local retry limit reached`, {
+              error,
+              dispatchAttempts
+            });
           }
         }
+      } finally {
+        setImmediate(() => {
+          this.executing = null;
+          if (next || this.pending.length) {
+            this.plugin.getLogger("dispatcher").debug(`last process finished, will do another dispatch`);
+            this.dispatch();
+          }
+        });
       }
-      setImmediate(() => {
-        this.executing = null;
-        if (next || this.pending.length) {
-          this.plugin.getLogger("dispatcher").debug(`last process finished, will do another dispatch`);
-          this.dispatch();
-        }
-      });
     })();
   }
   async run(pending) {
@@ -285,8 +303,15 @@ class Dispatcher {
     }
     return valid;
   }
-  async createExecution(workflow, context, options) {
+  async handleTriggerFail(workflow, context, options, error) {
     var _a;
+    try {
+      await ((_a = options.onTriggerFail) == null ? void 0 : _a.call(options, workflow, context, options, error));
+    } catch (triggerFailError) {
+      this.plugin.getLogger(workflow.id).error(`trigger failure callback failed`, { error: triggerFailError });
+    }
+  }
+  async createExecution(workflow, context, options) {
     const { deferred } = options;
     let stack = options.stack;
     if (options.parentExecutionId && !stack) {
@@ -295,21 +320,34 @@ class Dispatcher {
       });
       stack = parentExecution ? [...parentExecution.stack ?? [], parentExecution.id] : [];
     }
-    const valid = await this.validateEvent(workflow, context, { ...options, stack });
+    let valid;
+    try {
+      valid = await this.validateEvent(workflow, context, { ...options, stack });
+    } catch (error) {
+      await this.handleTriggerFail(workflow, context, options, error);
+      throw error;
+    }
     if (!valid) {
-      (_a = options.onTriggerFail) == null ? void 0 : _a.call(options, workflow, context, options);
-      throw new Error("event is not valid");
-    }
-    const execution = await workflow.createExecution({
-      context,
-      key: workflow.key,
-      eventKey: options.eventKey ?? (0, import_node_crypto.randomUUID)(),
-      stack,
-      parentExecutionId: options.parentExecutionId ?? null,
-      dispatched: deferred ?? false,
-      status: deferred ? import_constants.EXECUTION_STATUS.STARTED : import_constants.EXECUTION_STATUS.QUEUEING,
-      manually: options.manually
-    });
+      const error = new Error("event is not valid");
+      await this.handleTriggerFail(workflow, context, options, error);
+      throw error;
+    }
+    let execution;
+    try {
+      execution = await workflow.createExecution({
+        context,
+        key: workflow.key,
+        eventKey: options.eventKey ?? (0, import_node_crypto.randomUUID)(),
+        stack,
+        parentExecutionId: options.parentExecutionId ?? null,
+        dispatched: deferred ?? false,
+        status: deferred ? import_constants.EXECUTION_STATUS.STARTED : import_constants.EXECUTION_STATUS.QUEUEING,
+        manually: options.manually
+      });
+    } catch (error) {
+      await this.handleTriggerFail(workflow, context, options, error);
+      throw error;
+    }
     this.plugin.getLogger(workflow.id).info(`execution of workflow ${workflow.id} created as ${execution.id}`);
     if (!workflow.stats) {
       workflow.stats = await workflow.getStats();
@@ -332,8 +370,7 @@ class Dispatcher {
     const logger = input ? this.plugin.getLogger(input.workflowId) : this.plugin.getLogger("dispatcher");
     if (options.transaction) {
       try {
-        const { execution } = await this.acquireExecution(input, options, options.transaction);
-        return execution;
+        return await this.acquireExecution(input, options, options.transaction);
       } catch (error) {
         if (error instanceof Error) {
           logger.error(`entering execution failed: ${error.message}`, { error });
@@ -346,13 +383,12 @@ class Dispatcher {
       await this.acquireWithRetry(
         async () => {
           const tx = await this.plugin.db.sequelize.transaction({
-            isolationLevel: this.plugin.db.options.dialect === "sqlite" ? void 0 : import_sequelize.Transaction.ISOLATION_LEVELS.REPEATABLE_READ
+            isolationLevel: this.plugin.db.options.dialect === "sqlite" ? void 0 : import_sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED
           });
           try {
-            const { execution, shouldRetry } = await this.acquireExecution(input, options, tx);
+            const execution = await this.acquireExecution(input, options, tx);
             await tx.commit();
             result = execution;
-            return shouldRetry;
           } catch (error) {
             await tx.rollback();
             if (this.isConcurrentAcquireError(error)) {
@@ -362,7 +398,6 @@ class Dispatcher {
               logger.error(`entering execution failed: ${error.message}`, { error });
             }
             result = null;
-            return false;
           }
         },
         {
@@ -386,10 +421,17 @@ class Dispatcher {
         await execution.reload({ transaction });
       }
     } else {
+      const workflowIds = [...this.plugin.enabledCache.keys()];
+      if (!workflowIds.length) {
+        this.plugin.getLogger("dispatcher").debug(`no enabled workflow to process`);
+        return null;
+      }
       execution = await this.plugin.db.getRepository("executions").findOne({
         filter: {
           dispatched: false,
-          "workflow.enabled": true
+          status: import_constants.EXECUTION_STATUS.QUEUEING,
+          startedAt: null,
+          workflowId: workflowIds
         },
         sort: "id",
         transaction,
@@ -403,30 +445,24 @@ class Dispatcher {
       }
     }
     if (!execution) {
-      return { execution: null, shouldRetry: false };
+      return null;
     }
-    const entered = await this.enter(execution, transaction);
-    const shouldRetry = !input && !entered;
-    return { execution: entered, shouldRetry };
+    return this.enter(execution, transaction);
   }
   async acquireWithRetry(acquire, options) {
     for (let attempt = 1; attempt <= EXECUTION_ACQUIRE_MAX_ATTEMPTS; attempt++) {
-      let shouldRetry = false;
       try {
-        shouldRetry = await acquire();
+        await acquire();
+        break;
       } catch (error) {
         if (!this.isConcurrentAcquireError(error)) {
           throw error;
         }
-        shouldRetry = true;
         options.logger.warn(options.conflictMessage, { error });
-      }
-      if (!shouldRetry) {
-        break;
-      }
-      if (attempt >= EXECUTION_ACQUIRE_MAX_ATTEMPTS) {
-        options.logger.warn(options.maxAttemptsMessage);
-        break;
+        if (attempt >= EXECUTION_ACQUIRE_MAX_ATTEMPTS) {
+          options.logger.warn(options.maxAttemptsMessage);
+          break;
+        }
       }
     }
   }

package/dist/server/ExecutionTimeoutManager.js

@@ -81,10 +81,10 @@ class ExecutionTimeoutManager {
     await ((_a = this.scanning) == null ? void 0 : _a.catch(() => {
     }));
   }
-  isExpired(execution, now = /* @__PURE__ */ new Date()) {
+  isExpired(execution, now = new Date(Date.now())) {
     return !!execution.expiresAt && execution.expiresAt.getTime() <= now.getTime();
   }
-  getRemainingMs(execution, now = /* @__PURE__ */ new Date()) {
+  getRemainingMs(execution, now = new Date(Date.now())) {
     if (!execution.expiresAt) {
       return null;
     }

package/dist/server/Plugin.d.ts

@@ -74,7 +74,7 @@ export default class PluginWorkflowServer extends Plugin {
      */
     load(): Promise<void>;
     private toggle;
-    trigger(workflow: WorkflowModel, context: object, options?: EventOptions): void | Promise<Processor | null>;
+    trigger(workflow: WorkflowModel, context: object, options?: EventOptions): void | Promise<Processor | null | void>;
     run(pending: Parameters<Dispatcher['run']>[0]): Promise<void>;
     dispatch(): void;
     resume(job: any): Promise<void>;

package/dist/server/Processor.d.ts

@@ -29,6 +29,12 @@ export type BackgroundAbortHandle = {
     dispose: () => void;
     throwIfAborted: () => void;
 };
+export type ScopeTransaction = {
+    transaction: Transaction;
+    dataSource: string;
+    isolationLevel?: string;
+    closing?: 'commit' | 'rollback';
+};
 export default class Processor {
     execution: ExecutionModel;
     options: ProcessorOptions;
@@ -58,6 +64,7 @@ export default class Processor {
     private jobsMapByNodeKey;
     private jobResultsMapByNodeKey;
     private jobsToSave;
+    private scopeTransactions;
     private rerunContext;
     /**
      * @experimental
@@ -111,6 +118,15 @@ export default class Processor {
     end(node: FlowNodeModel, job: JobModel): Promise<any>;
     private recall;
     exit(s?: number | true): Promise<any>;
+    setScopeTransaction(key: string, info: ScopeTransaction): void;
+    getScopeTransactionByKey(key: string): ScopeTransaction;
+    clearScopeTransaction(key: string): void;
+    markScopeTransactionClosing(key: string, action: 'commit' | 'rollback'): void;
+    getScopeTransaction(node: FlowNodeModel, dataSourceName?: string): Transaction | null;
+    isInstructionSync(node: FlowNodeModel): boolean;
+    private hasOpenScopeTransactions;
+    private markOpenScopePendingJobsAsError;
+    private cleanupScopeTransactions;
     /**
      * @experimental
      */

package/dist/server/Processor.js

@@ -46,6 +46,7 @@ var import_utils = require("@nocobase/utils");
 var import_set = __toESM(require("lodash/set"));
 var import_constants = require("./constants");
 var import_timeout_errors = require("./timeout-errors");
+const OPEN_SCOPE_PENDING_ERROR = "Pending jobs are not allowed inside an open transaction scope";
 class Processor {
   constructor(execution, options) {
     this.execution = execution;
@@ -79,6 +80,7 @@ class Processor {
   jobsMapByNodeKey = {};
   jobResultsMapByNodeKey = {};
   jobsToSave = /* @__PURE__ */ new Map();
+  scopeTransactions = /* @__PURE__ */ new Map();
   rerunContext = null;
   /**
    * @experimental
@@ -447,6 +449,15 @@ class Processor {
     if (s === true) {
       return;
     }
+    if ((s == null || s === import_constants.JOB_STATUS.PENDING) && this.hasOpenScopeTransactions()) {
+      this.markOpenScopePendingJobsAsError(OPEN_SCOPE_PENDING_ERROR);
+      s = import_constants.JOB_STATUS.ERROR;
+    }
+    const hadScopeTransactions = this.scopeTransactions.size > 0;
+    await this.cleanupScopeTransactions({ allowCommit: s === import_constants.JOB_STATUS.RESOLVED });
+    if (hadScopeTransactions && s == null && this.execution.status === import_constants.EXECUTION_STATUS.STARTED) {
+      s = import_constants.JOB_STATUS.ERROR;
+    }
     if (this.jobsToSave.size) {
       const newJobs = [];
       for (const job of this.jobsToSave.values()) {
@@ -520,6 +531,107 @@ class Processor {
     });
     return null;
   }
+  setScopeTransaction(key, info) {
+    this.scopeTransactions.set(key, info);
+  }
+  getScopeTransactionByKey(key) {
+    return this.scopeTransactions.get(key) ?? null;
+  }
+  clearScopeTransaction(key) {
+    this.scopeTransactions.delete(key);
+  }
+  markScopeTransactionClosing(key, action) {
+    const scopeTransaction = this.scopeTransactions.get(key);
+    if (scopeTransaction) {
+      scopeTransaction.closing = action;
+    }
+  }
+  getScopeTransaction(node, dataSourceName) {
+    for (let current = node; current; current = current.upstream) {
+      const scopeTransaction = this.scopeTransactions.get(current.key);
+      if (!scopeTransaction) {
+        continue;
+      }
+      if (dataSourceName && scopeTransaction.dataSource !== dataSourceName) {
+        continue;
+      }
+      const branchStartNode = this.findBranchStartNode(node, current);
+      if ((branchStartNode == null ? void 0 : branchStartNode.branchIndex) !== 1) {
+        continue;
+      }
+      return scopeTransaction.transaction;
+    }
+    return null;
+  }
+  isInstructionSync(node) {
+    return this.options.plugin.isWorkflowSync(this.execution.workflow) || Boolean(this.getScopeTransaction(node));
+  }
+  hasOpenScopeTransactions() {
+    for (const { transaction } of this.scopeTransactions.values()) {
+      if (!transaction.finished) {
+        return true;
+      }
+    }
+    return false;
+  }
+  markOpenScopePendingJobsAsError(message) {
+    const pendingJobs = /* @__PURE__ */ new Set();
+    for (const job of this.jobsToSave.values()) {
+      if (job.status === import_constants.JOB_STATUS.PENDING) {
+        pendingJobs.add(job);
+      }
+    }
+    for (const job of Object.values(this.jobsMapByNodeKey)) {
+      if (job.status === import_constants.JOB_STATUS.PENDING) {
+        pendingJobs.add(job);
+      }
+    }
+    for (const key of this.scopeTransactions.keys()) {
+      const job = this.jobsMapByNodeKey[key];
+      if ((job == null ? void 0 : job.status) === import_constants.JOB_STATUS.PENDING) {
+        pendingJobs.add(job);
+      }
+    }
+    for (const job of pendingJobs) {
+      job.set({
+        status: import_constants.JOB_STATUS.ERROR,
+        result: {
+          message
+        }
+      });
+      this.saveJob(job);
+    }
+  }
+  async cleanupScopeTransactions({ allowCommit = false } = {}) {
+    if (!this.scopeTransactions.size) {
+      return;
+    }
+    for (const [key, { transaction, dataSource, closing }] of Array.from(this.scopeTransactions.entries()).reverse()) {
+      const tx = transaction;
+      if (tx.finished) {
+        this.scopeTransactions.delete(key);
+        continue;
+      }
+      const action = closing === "commit" && allowCommit ? "commit" : "rollback";
+      const actionText = action === "commit" ? "committing" : "rolling back";
+      this.logger.warn(
+        `scope transaction (${key}) on data source "${dataSource}" was not closed before exit, ${actionText}`,
+        {
+          workflowId: this.execution.workflowId
+        }
+      );
+      try {
+        await tx[action]();
+      } catch (error) {
+        this.logger.error(`scope transaction (${key}) fallback ${action} failed`, {
+          error,
+          workflowId: this.execution.workflowId
+        });
+      } finally {
+        this.scopeTransactions.delete(key);
+      }
+    }
+  }
   /**
    * @experimental
    */

package/dist/server/actions/nodes.js

@@ -78,6 +78,23 @@ function validateNode(context, workflow, values) {
     }
   }
 }
+async function touchWorkflow(context, workflowId, transaction) {
+  var _a, _b;
+  const values = {
+    updatedAt: /* @__PURE__ */ new Date()
+  };
+  const currentUserId = (_b = (_a = context.state) == null ? void 0 : _a.currentUser) == null ? void 0 : _b.id;
+  if (currentUserId != null) {
+    values.updatedById = currentUserId;
+  }
+  await context.db.getCollection("workflows").model.update(values, {
+    where: {
+      id: workflowId
+    },
+    transaction,
+    hooks: false
+  });
+}
 async function create(context, next) {
   const { db } = context;
   const repository = import_actions.utils.getRepositoryFromParams(context);
@@ -122,6 +139,7 @@ async function create(context, next) {
         await instance.setDownstream(previousHead, { transaction });
         instance.set("downstream", previousHead);
       }
+      await touchWorkflow(context, workflow.id, transaction);
       return instance;
     }
     const upstream = await instance.getUpstream({ transaction });
@@ -162,6 +180,7 @@ async function create(context, next) {
       }
     }
     instance.set("upstream", upstream);
+    await touchWorkflow(context, workflow.id, transaction);
     return instance;
   });
   await next();
@@ -233,6 +252,7 @@ async function duplicate(context, next) {
         await instance.setDownstream(previousHead, { transaction });
         instance.set("downstream", previousHead);
       }
+      await touchWorkflow(context, origin.workflowId, transaction);
       return instance;
     }
     const upstream = await instance.getUpstream({ transaction });
@@ -273,6 +293,7 @@ async function duplicate(context, next) {
       }
     }
     instance.set("upstream", upstream);
+    await touchWorkflow(context, origin.workflowId, transaction);
     return instance;
   });
   await next();
@@ -401,6 +422,7 @@ async function destroy(context, next) {
       filterByTk: [instance.id, ...branchNodesToDelete.map((item) => item.id)],
       transaction
     });
+    await touchWorkflow(context, instance.workflowId, transaction);
   });
   context.body = instance;
   await next();
@@ -431,6 +453,7 @@ async function destroyBranch(context, next) {
   }
   let deletedBranchHead = null;
   await db.sequelize.transaction(async (transaction) => {
+    let shouldTouchWorkflow = false;
     const nodes = await repository.find({
       filter: {
         workflowId: instance.workflowId
@@ -461,6 +484,7 @@ async function destroyBranch(context, next) {
           filterByTk: idsToDelete,
           transaction
         });
+        shouldTouchWorkflow = true;
       }
     }
     if (shift) {
@@ -475,6 +499,12 @@ async function destroyBranch(context, next) {
           )
         )
       );
+      if (headsToShift.length) {
+        shouldTouchWorkflow = true;
+      }
+    }
+    if (shouldTouchWorkflow) {
+      await touchWorkflow(context, instance.workflowId, transaction);
     }
   });
   context.body = deletedBranchHead;
@@ -579,6 +609,7 @@ async function move(context, next) {
         },
         { transaction }
       );
+      await touchWorkflow(context, instance.workflowId, transaction);
       return instance;
     }
     if (branchIndex == null) {
@@ -612,6 +643,7 @@ async function move(context, next) {
         },
         { transaction }
       );
+      await touchWorkflow(context, instance.workflowId, transaction);
       return instance;
     }
     const branchHead = await repository.findOne({
@@ -640,6 +672,7 @@ async function move(context, next) {
       },
       { transaction }
     );
+    await touchWorkflow(context, instance.workflowId, transaction);
     return instance;
   });
   await next();
@@ -660,7 +693,7 @@ async function update(context, next) {
     }
     const merged = Object.assign({}, instance.get(), values);
     validateNode(context, null, merged);
-    return repository.update({
+    const result = await repository.update({
       filterByTk,
       values,
       whitelist,
@@ -670,6 +703,8 @@ async function update(context, next) {
       context,
       transaction
     });
+    await touchWorkflow(context, instance.workflowId, transaction);
+    return result;
   });
   await next();
 }

package/dist/server/index.d.ts

@@ -15,6 +15,6 @@ export * from './timeout-errors';
 export { Trigger } from './triggers';
 export type { EventOptions } from './Dispatcher';
 export { default as Processor } from './Processor';
-export type { BackgroundAbortHandle, ProcessorOptions } from './Processor';
+export type { BackgroundAbortHandle, ProcessorOptions, ScopeTransaction } from './Processor';
 export { default } from './Plugin';
 export * from './types';

package/dist/server/instructions/CreateInstruction.js

@@ -63,9 +63,13 @@ class CreateInstruction extends import__.Instruction {
   async run(node, input, processor) {
     const { collection, params: { appends = [], ...params } = {} } = node.config;
     const [dataSourceName, collectionName] = (0, import_data_source_manager.parseCollectionName)(collection);
-    const { repository, filterTargetKey } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const dataSource = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName);
+    if (!dataSource) {
+      throw new Error(`Data source ${dataSourceName} not found`);
+    }
+    const { repository, filterTargetKey } = dataSource.collectionManager.getCollection(collectionName);
     const options = processor.getParsedValue(params, node.id);
-    const transaction = this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction);
+    const transaction = processor.getScopeTransaction(node, dataSourceName) ?? this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction);
     const created = await repository.create({
       ...options,
       context: {

package/dist/server/instructions/DestroyInstruction.js

@@ -64,12 +64,13 @@ class DestroyInstruction extends import__.Instruction {
     const [dataSourceName, collectionName] = (0, import_data_source_manager.parseCollectionName)(collection);
     const { repository } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
     const options = processor.getParsedValue(params, node.id);
+    const transaction = processor.getScopeTransaction(node, dataSourceName) ?? this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction);
     const result = await repository.destroy({
       ...options,
       context: {
         stack: Array.from(new Set((processor.execution.stack ?? []).concat(processor.execution.id)))
       },
-      transaction: this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction)
+      transaction
     });
     return {
       result,

package/dist/server/instructions/QueryInstruction.js

@@ -78,6 +78,7 @@ class QueryInstruction extends import__.Instruction {
         return set;
       }, /* @__PURE__ */ new Set())
     ) : options.appends;
+    const transaction = processor.getScopeTransaction(node, dataSourceName) ?? this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction);
     const result = await (multiple ? repository.find : repository.findOne).call(repository, {
       ...options,
       ...import_actions.utils.pageArgsToLimitArgs(page ?? import_actions.DEFAULT_PAGE, pageSize ?? import_actions.DEFAULT_PER_PAGE),
@@ -86,7 +87,7 @@ class QueryInstruction extends import__.Instruction {
         return `${((_a = item.direction) == null ? void 0 : _a.toLowerCase()) === "desc" ? "-" : ""}${item.field}`;
       }),
       appends,
-      transaction: this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction)
+      transaction
     });
     if (failOnEmpty && (multiple ? !result.length : !result)) {
       return {