@nocobase/plugin-workflow 2.1.0-beta.36 → 2.1.0-beta.38

package/dist/server/Processor.js

@@ -45,6 +45,7 @@ var import_evaluators = require("@nocobase/evaluators");
 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");
 class Processor {
   constructor(execution, options) {
     this.execution = execution;
@@ -66,11 +67,11 @@ class Processor {
   /**
    * @experimental
    */
-  transaction;
+  transaction = null;
   /**
    * @experimental
    */
-  mainTransaction;
+  mainTransaction = null;
   /**
    * @experimental
    */
@@ -82,10 +83,102 @@ class Processor {
   jobsMapByNodeKey = {};
   jobResultsMapByNodeKey = {};
   jobsToSave = /* @__PURE__ */ new Map();
+  rerunContext = null;
   /**
    * @experimental
    */
   lastSavedJob = null;
+  abortController = new AbortController();
+  timeoutGuard = null;
+  runningRegistered = false;
+  abortReason = null;
+  aborted = false;
+  get abortSignal() {
+    return this.abortController.signal;
+  }
+  setTimeoutGuard(ms) {
+    if (this.timeoutGuard) {
+      clearTimeout(this.timeoutGuard);
+    }
+    this.timeoutGuard = setTimeout(() => {
+      this.abortExecution(import_constants.EXECUTION_REASON.TIMEOUT);
+    }, ms);
+  }
+  abortExecution(reason) {
+    this.aborted = true;
+    this.abortReason = reason ?? null;
+    if (!this.abortController.signal.aborted) {
+      this.abortController.abort(
+        reason === import_constants.EXECUTION_REASON.TIMEOUT ? new import_timeout_errors.WorkflowTimeoutError("Workflow execution has been aborted") : new Error("Workflow execution has been aborted")
+      );
+    }
+  }
+  isTimeoutAborted() {
+    return this.abortSignal.aborted;
+  }
+  /**
+   * Create an independent abort handle for background work that outlives this processor's
+   * run loop (e.g. fire-and-forget instructions that resume the job later). It mirrors the
+   * current abort state and sets its own timer based on the execution's `expiresAt`, so the
+   * timeout still applies after the processor has exited its synchronous run.
+   *
+   * The caller must invoke `dispose()` once the background work settles to release the timer
+   * and the abort listener.
+   */
+  createBackgroundAbortHandle() {
+    const controller = new AbortController();
+    const sourceSignal = this.abortSignal;
+    let timeoutGuard = null;
+    let sourceListener = null;
+    const abort = (reason) => {
+      if (!controller.signal.aborted) {
+        controller.abort((0, import_timeout_errors.isWorkflowTimeoutError)(reason) ? reason : new import_timeout_errors.WorkflowTimeoutError());
+      }
+    };
+    if (sourceSignal.aborted) {
+      abort(sourceSignal.reason);
+    } else {
+      sourceListener = () => abort(sourceSignal.reason);
+      sourceSignal.addEventListener("abort", sourceListener, { once: true });
+    }
+    const remaining = this.execution.expiresAt ? this.execution.expiresAt.getTime() - Date.now() : null;
+    if (remaining != null) {
+      if (remaining <= 0) {
+        abort();
+      } else {
+        timeoutGuard = setTimeout(abort, remaining);
+      }
+    }
+    return {
+      signal: controller.signal,
+      dispose: () => {
+        if (timeoutGuard) {
+          clearTimeout(timeoutGuard);
+          timeoutGuard = null;
+        }
+        if (sourceListener) {
+          sourceSignal.removeEventListener("abort", sourceListener);
+          sourceListener = null;
+        }
+      },
+      throwIfAborted: () => {
+        if (controller.signal.aborted) {
+          throw controller.signal.reason ?? new import_timeout_errors.WorkflowTimeoutError();
+        }
+      }
+    };
+  }
+  /**
+   * Reload a job and return it only when it is still pending, otherwise `null`. Background
+   * work uses this before resuming so it never overwrites a job that another path (timeout
+   * abort, a competing resume) has already settled.
+   */
+  async findPendingJob(jobId) {
+    const job = await this.options.plugin.db.getRepository("jobs").findOne({
+      filterByTk: jobId
+    });
+    return (job == null ? void 0 : job.status) === import_constants.JOB_STATUS.PENDING ? job : null;
+  }
   // make dual linked nodes list then cache
   makeNodes(nodes = []) {
     this.nodes = nodes;
@@ -122,6 +215,9 @@ class Processor {
     if (!execution.workflow) {
       execution.workflow = plugin.enabledCache.get(execution.workflowId) || await execution.getWorkflow({ transaction });
     }
+    if (!execution.workflow) {
+      throw new Error(`workflow (#${execution.workflowId}) not found for execution (#${execution.id})`);
+    }
     const nodes = execution.workflow.nodes || await execution.workflow.getNodes({ transaction });
     execution.workflow.nodes = nodes;
     this.makeNodes(nodes);
@@ -147,37 +243,117 @@ class Processor {
   }
   async start() {
     const { execution } = this;
-    if (execution.status) {
+    if (!await this.shouldContinueExecution()) {
       this.logger.warn(`execution was ended with status ${execution.status} before, could not be started again`, {
         workflowId: execution.workflowId
       });
       return;
     }
-    await this.prepare();
-    if (this.nodes.length) {
-      const head = this.nodes.find((item) => !item.upstream);
-      await this.run(head, { result: execution.context });
-    } else {
-      await this.exit(import_constants.JOB_STATUS.RESOLVED);
+    this.enterRunningState();
+    try {
+      await this.prepare();
+      if (this.nodes.length) {
+        const head = this.nodes.find((item) => !item.upstream);
+        if (!head) {
+          this.logger.warn(`head node not found for workflow (${execution.workflowId}), could not be started`, {
+            workflowId: execution.workflowId
+          });
+          return this.exit(import_constants.JOB_STATUS.ERROR);
+        }
+        await this.run(head);
+      } else {
+        await this.exit(import_constants.JOB_STATUS.RESOLVED);
+      }
+    } finally {
+      this.leaveRunningState();
     }
   }
   async resume(job) {
     const { execution } = this;
-    if (execution.status) {
+    if (!await this.shouldContinueExecution()) {
       this.logger.warn(`execution was ended with status ${execution.status} before, could not be resumed`, {
         workflowId: execution.workflowId
       });
       return;
     }
-    await this.prepare();
-    const node = this.nodesMap.get(job.nodeId);
-    await this.recall(node, job);
+    this.enterRunningState();
+    try {
+      await this.prepare();
+      const node = this.nodesMap.get(job.nodeId);
+      await this.recall(node, job);
+    } finally {
+      this.leaveRunningState();
+    }
+  }
+  resolveRerun(options = {}) {
+    const node = this.getRerunNode(options.nodeId);
+    const targetJob = this.jobsMapByNodeKey[node.key];
+    if (options.nodeId != null && !targetJob) {
+      throw new Error(`job of node (#${node.id}) not found in execution (#${this.execution.id})`);
+    }
+    if (options.nodeId == null && options.overwrite && !targetJob) {
+      throw new Error(`job of head node (#${node.id}) not found in execution (#${this.execution.id})`);
+    }
+    const input = this.getRerunInput(node);
+    return { node, input, targetJob };
+  }
+  async rerun(options = {}) {
+    const { execution } = this;
+    if (execution.status !== import_constants.EXECUTION_STATUS.STARTED) {
+      throw new Error(`execution (#${execution.id}) is not started`);
+    }
+    if (!await this.shouldContinueExecution()) {
+      this.logger.warn(`execution was ended with status ${execution.status} before, could not be rerun`, {
+        workflowId: execution.workflowId
+      });
+      return;
+    }
+    this.enterRunningState();
+    try {
+      await this.prepare();
+      const { node, input, targetJob } = this.resolveRerun(options);
+      this.rerunContext = {
+        overwrite: options.overwrite === true,
+        targetJob
+      };
+      return await this.run(node, input, { rerun: true });
+    } finally {
+      this.rerunContext = null;
+      this.leaveRunningState();
+    }
   }
-  async exec(instruction, node, prevJob) {
+  getRerunNode(nodeId) {
+    if (nodeId != null) {
+      const node = this.nodesMap.get(nodeId) || this.nodes.find((item) => String(item.id) === String(nodeId));
+      if (!node) {
+        throw new Error(`node (#${nodeId}) not found in workflow (#${this.execution.workflowId})`);
+      }
+      return node;
+    }
+    const head = this.nodes.find((item) => !item.upstream);
+    if (!head) {
+      throw new Error(`head node not found in workflow (#${this.execution.workflowId})`);
+    }
+    return head;
+  }
+  getRerunInput(node) {
+    if (!node.upstream) {
+      return { result: this.execution.context };
+    }
+    const upstreamJob = this.jobsMapByNodeKey[node.upstream.key];
+    if (!upstreamJob) {
+      throw new Error(`upstream job of node (#${node.id}) not found in execution (#${this.execution.id})`);
+    }
+    return upstreamJob;
+  }
+  async exec(instruction, node, prevJob, options = {}) {
     let job;
+    if (!await this.shouldContinueExecution()) {
+      return this.exit();
+    }
     try {
       this.logger.debug(`config of node`, { data: node.config, workflowId: node.workflowId });
-      job = await instruction(node, prevJob, this);
+      job = await instruction(node, prevJob, this, { ...options, signal: this.abortSignal });
       if (job === null) {
         return this.exit();
       }
@@ -185,18 +361,27 @@ class Processor {
         return this.exit(true);
       }
     } catch (err) {
-      this.logger.error(
-        `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) failed: `,
-        { error: err, workflowId: node.workflowId }
-      );
-      job = {
-        result: err instanceof Error ? {
-          message: err.message,
-          ...err
-        } : err,
-        status: import_constants.JOB_STATUS.ERROR
-      };
-      if (prevJob && prevJob.nodeId === node.id) {
+      if ((0, import_timeout_errors.isWorkflowTimeoutError)(err) || this.abortSignal.aborted && this.aborted) {
+        job = {
+          result: {
+            message: err.message
+          },
+          status: import_constants.JOB_STATUS.ABORTED
+        };
+      } else {
+        this.logger.error(
+          `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) failed: `,
+          { error: err, workflowId: node.workflowId }
+        );
+        job = {
+          result: err instanceof Error ? {
+            ...err,
+            message: err.message
+          } : err,
+          status: import_constants.JOB_STATUS.ERROR
+        };
+      }
+      if (prevJob instanceof import_database.Model && prevJob.nodeId === node.id) {
         prevJob.set(job);
         job = prevJob;
       }
@@ -213,13 +398,16 @@ class Processor {
       }
     );
     this.logger.debug(`result of node`, { data: savedJob.result });
+    if (this.execution.status === import_constants.EXECUTION_STATUS.ABORTED || this.isTimeoutAborted()) {
+      return this.exit(import_constants.JOB_STATUS.ABORTED);
+    }
     if (savedJob.status === import_constants.JOB_STATUS.RESOLVED && node.downstream) {
       this.logger.debug(`run next node (${node.downstreamId})`);
       return this.run(node.downstream, savedJob);
     }
     return this.end(node, savedJob);
   }
-  async run(node, input) {
+  async run(node, input, options) {
     const { instructions } = this.options.plugin;
     const instruction = instructions.get(node.type);
     if (!instruction) {
@@ -231,7 +419,7 @@ class Processor {
     this.logger.info(`execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id})`, {
       workflowId: node.workflowId
     });
-    return this.exec(instruction.run.bind(instruction), node, input);
+    return this.exec(instruction.run.bind(instruction), node, input, options);
   }
   // parent node should take over the control
   async end(node, job) {
@@ -263,6 +451,7 @@ class Processor {
     return this.exec(instruction.resume.bind(instruction), node, job);
   }
   async exit(s) {
+    this.leaveRunningState();
     if (s === true) {
       return;
     }
@@ -311,11 +500,34 @@ class Processor {
     }
     if (typeof s === "number") {
       const status = this.constructor.StatusMap[s] ?? Math.sign(s);
-      await this.execution.update({ status }, { transaction: this.mainTransaction });
+      const values = { status };
+      if (status === import_constants.EXECUTION_STATUS.ABORTED && this.abortReason) {
+        values.reason = this.abortReason;
+      }
+      const ExecutionModelClass = this.options.plugin.db.getModel("executions");
+      const [affected] = await ExecutionModelClass.update(values, {
+        where: {
+          id: this.execution.id,
+          status: import_constants.EXECUTION_STATUS.STARTED
+        },
+        individualHooks: true,
+        transaction: this.mainTransaction
+      });
+      if (affected) {
+        this.execution.set(values);
+      } else {
+        await this.execution.reload({ transaction: this.mainTransaction });
+      }
     }
     if (this.mainTransaction && this.mainTransaction !== this.transaction) {
       await this.mainTransaction.commit();
     }
+    if (this.execution.status === import_constants.EXECUTION_STATUS.STARTED) {
+      this.options.plugin.timeoutManager.scheduleExecutionTimeout(this.execution);
+    } else {
+      this.options.plugin.timeoutManager.clear(this.execution.id);
+      this.options.plugin.timeoutManager.invalidateNextExpiresAtIfMatches(this.execution.expiresAt);
+    }
     this.logger.info(`execution (${this.execution.id}) exiting with status ${this.execution.status}`, {
       workflowId: this.execution.workflowId
     });
@@ -325,12 +537,21 @@ class Processor {
    * @experimental
    */
   saveJob(payload) {
+    var _a;
     const { database } = this.execution.constructor;
-    const { model } = database.getCollection("jobs");
+    const model = database.getModel("jobs");
     let job;
     if (payload instanceof model) {
       job = payload;
       job.set("updatedAt", /* @__PURE__ */ new Date());
+    } else if (((_a = this.rerunContext) == null ? void 0 : _a.overwrite) && this.rerunContext.targetJob && this.rerunContext.targetJob.nodeId === payload.nodeId) {
+      job = this.rerunContext.targetJob;
+      job.set({
+        status: payload.status,
+        result: Object.prototype.hasOwnProperty.call(payload, "result") ? payload.result : null,
+        meta: Object.prototype.hasOwnProperty.call(payload, "meta") ? payload.meta : null,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
     } else {
       job = model.build(
         {
@@ -345,7 +566,7 @@ class Processor {
         }
       );
     }
-    this.jobsToSave.set(job.id, job);
+    this.jobsToSave.set(job.id.toString(), job);
     this.lastSavedJob = job;
     this.jobsMapByNodeKey[job.nodeKey] = job;
     this.jobResultsMapByNodeKey[job.nodeKey] = job.result;
@@ -360,6 +581,37 @@ class Processor {
   getBranches(node) {
     return this.nodes.filter((item) => item.upstream === node && item.branchIndex !== null).sort((a, b) => Number(a.branchIndex) - Number(b.branchIndex));
   }
+  enterRunningState() {
+    this.options.plugin.timeoutManager.clear(this.execution.id);
+    this.abortReason = null;
+    this.aborted = false;
+    this.options.plugin.registerRunningExecution(this.execution.id, (reason) => this.abortExecution(reason));
+    this.runningRegistered = true;
+    const remaining = this.execution.expiresAt ? this.execution.expiresAt.getTime() - Date.now() : null;
+    if (remaining == null) {
+      return;
+    }
+    if (remaining <= 0) {
+      this.abortExecution(import_constants.EXECUTION_REASON.TIMEOUT);
+      return;
+    }
+    this.setTimeoutGuard(remaining);
+  }
+  async shouldContinueExecution() {
+    const transaction = this.mainTransaction ?? this.transaction;
+    return this.options.plugin.timeoutManager.shouldContinue(this.execution, { transaction });
+  }
+  leaveRunningState() {
+    if (this.timeoutGuard) {
+      clearTimeout(this.timeoutGuard);
+      this.timeoutGuard = null;
+    }
+    if (!this.runningRegistered) {
+      return;
+    }
+    this.options.plugin.unregisterRunningExecution(this.execution.id);
+    this.runningRegistered = false;
+  }
   /**
    * @experimental
    * find the first node in current branch
@@ -423,7 +675,7 @@ class Processor {
    * @experimental
    */
   getScope(sourceNodeId, includeSelfScope = false) {
-    const node = this.nodesMap.get(sourceNodeId);
+    const node = sourceNodeId ? this.nodesMap.get(sourceNodeId) : void 0;
     const systemFns = {};
     const scope = {
       execution: this.execution,

package/dist/server/RunningExecutionRegistry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+type AbortHandler = {
+    abort(reason?: string): void;
+};
+export default class RunningExecutionRegistry {
+    private readonly executions;
+    register(executionId: number | string, handler: AbortHandler): void;
+    unregister(executionId: number | string): void;
+    abort(executionId: number | string, reason?: string): boolean;
+}
+export {};

package/dist/server/RunningExecutionRegistry.js

@@ -0,0 +1,48 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RunningExecutionRegistry_exports = {};
+__export(RunningExecutionRegistry_exports, {
+  default: () => RunningExecutionRegistry
+});
+module.exports = __toCommonJS(RunningExecutionRegistry_exports);
+class RunningExecutionRegistry {
+  executions = /* @__PURE__ */ new Map();
+  register(executionId, handler) {
+    this.executions.set(String(executionId), handler);
+  }
+  unregister(executionId) {
+    this.executions.delete(String(executionId));
+  }
+  abort(executionId, reason) {
+    const handler = this.executions.get(String(executionId));
+    if (!handler) {
+      return false;
+    }
+    handler.abort(reason);
+    return true;
+  }
+}

package/dist/server/actions/executions.d.ts

@@ -6,6 +6,7 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { Context } from '@nocobase/actions';
-export declare function destroy(context: Context, next: any): Promise<void>;
-export declare function cancel(context: Context, next: any): Promise<never>;
+import { Context, Next } from '@nocobase/actions';
+export declare function destroy(context: Context, next: Next): Promise<void>;
+export declare function cancel(context: Context, next: Next): Promise<never>;
+export declare function rerun(context: Context, next: Next): Promise<never>;

package/dist/server/actions/executions.js

@@ -37,12 +37,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var executions_exports = {};
 __export(executions_exports, {
   cancel: () => cancel,
-  destroy: () => destroy
+  destroy: () => destroy,
+  rerun: () => rerun
 });
 module.exports = __toCommonJS(executions_exports);
 var import_actions = __toESM(require("@nocobase/actions"));
 var import_database = require("@nocobase/database");
+var import_Plugin = __toESM(require("../Plugin"));
 var import_constants = require("../constants");
+var import_utils = require("../utils");
 async function destroy(context, next) {
   context.action.mergeParams({
     filter: {
@@ -55,8 +58,8 @@ async function destroy(context, next) {
 }
 async function cancel(context, next) {
   const { filterByTk } = context.action.params;
+  const workflowPlugin = context.app.pm.get(import_Plugin.default);
   const ExecutionRepo = context.db.getRepository("executions");
-  const JobRepo = context.db.getRepository("jobs");
   const execution = await ExecutionRepo.findOne({
     filterByTk,
     appends: ["jobs"]
@@ -67,30 +70,48 @@ async function cancel(context, next) {
   if (execution.status) {
     return context.throw(400);
   }
-  await context.db.sequelize.transaction(async (transaction) => {
-    await execution.update(
-      {
-        status: import_constants.EXECUTION_STATUS.ABORTED
-      },
-      { transaction }
-    );
-    const pendingJobs = execution.jobs.filter((job) => job.status === import_constants.JOB_STATUS.PENDING);
-    await JobRepo.update({
-      values: {
-        status: import_constants.JOB_STATUS.ABORTED
-      },
-      filter: {
-        id: pendingJobs.map((job) => job.id)
-      },
-      individualHooks: false,
-      transaction
-    });
+  try {
+    const lock = await context.app.lockManager.tryAcquire((0, import_utils.getExecutionLockKey)(execution.id));
+    await lock.runExclusive(async () => {
+      await (0, import_utils.abortExecution)(workflowPlugin, execution, { reason: import_constants.EXECUTION_REASON.MANUAL_CANCEL });
+    }, 6e4);
+  } catch (error) {
+    if ((0, import_utils.isLockAcquireError)(error)) {
+      return context.throw(409, "Execution is being processed");
+    }
+    throw error;
+  }
+  context.body = execution;
+  await next();
+}
+async function rerun(context, next) {
+  const workflowPlugin = context.app.pm.get(import_Plugin.default);
+  const { filterByTk, values = {} } = context.action.params;
+  const { nodeId, overwrite } = values;
+  const ExecutionRepo = context.db.getRepository("executions");
+  const execution = await ExecutionRepo.findOne({
+    filterByTk
+  });
+  if (!execution) {
+    return context.throw(404);
+  }
+  if (execution.status !== import_constants.EXECUTION_STATUS.STARTED) {
+    return context.throw(400, "Only started executions can be rerun");
+  }
+  await workflowPlugin.run({
+    execution,
+    rerun: {
+      nodeId,
+      overwrite: overwrite === true
+    }
   });
   context.body = execution;
+  context.status = 202;
   await next();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   cancel,
-  destroy
+  destroy,
+  rerun
 });

package/dist/server/actions/jobs.d.ts

@@ -6,4 +6,5 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-export declare function resume(context: any, next: any): Promise<any>;
+import { Context, Next } from '@nocobase/actions';
+export declare function resume(context: Context, next: Next): Promise<never>;

package/dist/server/actions/jobs.js

@@ -40,7 +40,10 @@ __export(jobs_exports, {
 });
 module.exports = __toCommonJS(jobs_exports);
 var import_actions = require("@nocobase/actions");
+var import_constants = require("../constants");
 var import_Plugin = __toESM(require("../Plugin"));
+var import_constants2 = require("../../common/constants");
+var import_utils = require("../utils");
 async function resume(context, next) {
   const repository = import_actions.utils.getRepositoryFromParams(context);
   const workflowPlugin = context.app.pm.get(import_Plugin.default);
@@ -51,11 +54,35 @@ async function resume(context, next) {
   if (!job) {
     return context.throw(404, "Job not found");
   }
+  if (!job.execution) {
+    job.execution = await job.getExecution();
+  }
   workflowPlugin.getLogger(job.workflowId).warn(`Resuming job #${job.id}...`);
-  await job.update(values);
+  const execution = job.execution;
+  if (!execution) {
+    return context.throw(400, "Execution is not running");
+  }
+  if (await workflowPlugin.abortExecutionIfExpired(execution)) {
+    return context.throw(400, context.t("Execution timed out", { ns: import_constants2.NAMESPACE }));
+  }
+  if (execution.status !== import_constants.EXECUTION_STATUS.STARTED) {
+    return context.throw(400, "Execution is not running");
+  }
+  try {
+    const lock = await context.app.lockManager.tryAcquire((0, import_utils.getExecutionLockKey)(job.execution.id));
+    await lock.runExclusive(async () => {
+      await job.update(values);
+    }, 6e4);
+  } catch (error) {
+    if ((0, import_utils.isLockAcquireError)(error)) {
+      return context.throw(409, "Execution is being processed");
+    }
+    throw error;
+  }
   context.body = job;
   context.status = 202;
   await next();
+  job.execution = execution;
   workflowPlugin.resume(job);
 }
 // Annotate the CommonJS export names for ESM import in node: