@nocobase/plugin-workflow 0.18.0-alpha.9 → 0.19.0-alpha.10

package/dist/server/Plugin.js

@@ -27,7 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Plugin_exports = {};
 __export(Plugin_exports, {
-  default: () => WorkflowPlugin
+  default: () => PluginWorkflowServer
 });
 module.exports = __toCommonJS(Plugin_exports);
 var import_path = __toESM(require("path"));
@@ -43,11 +43,12 @@ var import_CollectionTrigger = __toESM(require("./triggers/CollectionTrigger"));
 var import_ScheduleTrigger = __toESM(require("./triggers/ScheduleTrigger"));
 var import_CalculationInstruction = __toESM(require("./instructions/CalculationInstruction"));
 var import_ConditionInstruction = __toESM(require("./instructions/ConditionInstruction"));
+var import_EndInstruction = __toESM(require("./instructions/EndInstruction"));
 var import_CreateInstruction = __toESM(require("./instructions/CreateInstruction"));
 var import_DestroyInstruction = __toESM(require("./instructions/DestroyInstruction"));
 var import_QueryInstruction = __toESM(require("./instructions/QueryInstruction"));
 var import_UpdateInstruction = __toESM(require("./instructions/UpdateInstruction"));
-class WorkflowPlugin extends import_server.Plugin {
+class PluginWorkflowServer extends import_server.Plugin {
   instructions = new import_utils.Registry();
   triggers = new import_utils.Registry();
   functions = new import_utils.Registry();
@@ -73,6 +74,13 @@ class WorkflowPlugin extends import_server.Plugin {
     this.loggerCache.set(key, logger);
     return logger;
   }
+  isWorkflowSync(workflow) {
+    const trigger = this.triggers.get(workflow.type);
+    if (!trigger) {
+      throw new Error(`invalid trigger type ${workflow.type} of workflow ${workflow.id}`);
+    }
+    return trigger.sync ?? workflow.sync;
+  }
   onBeforeSave = async (instance, options) => {
     const Model = instance.constructor;
     if (instance.enabled) {
@@ -140,6 +148,7 @@ class WorkflowPlugin extends import_server.Plugin {
   initInstructions(more = {}) {
     this.registerInstruction("calculation", import_CalculationInstruction.default);
     this.registerInstruction("condition", import_ConditionInstruction.default);
+    this.registerInstruction("end", import_EndInstruction.default);
     this.registerInstruction("create", import_CreateInstruction.default);
     this.registerInstruction("destroy", import_DestroyInstruction.default);
     this.registerInstruction("query", import_QueryInstruction.default);
@@ -173,6 +182,7 @@ class WorkflowPlugin extends import_server.Plugin {
         "workflows.nodes:*",
         "executions:list",
         "executions:get",
+        "executions:cancel",
         "flow_nodes:update",
         "flow_nodes:destroy"
       ]
@@ -182,9 +192,7 @@ class WorkflowPlugin extends import_server.Plugin {
       actions: ["workflows:list"]
     });
     this.app.acl.allow("workflows", ["trigger"], "loggedIn");
-    await db.import({
-      directory: import_path.default.resolve(__dirname, "collections")
-    });
+    await this.importCollections(import_path.default.resolve(__dirname, "collections"));
     this.db.addMigrations({
       namespace: this.name,
       directory: import_path.default.resolve(__dirname, "migrations"),
@@ -210,8 +218,8 @@ class WorkflowPlugin extends import_server.Plugin {
       this.dispatch();
     });
     this.app.on("beforeStop", async () => {
-      const collection = db.getCollection("workflows");
-      const workflows = await collection.repository.find({
+      const repository = db.getRepository("workflows");
+      const workflows = await repository.find({
         filter: { enabled: true }
       });
       workflows.forEach((workflow) => {
@@ -233,7 +241,7 @@ class WorkflowPlugin extends import_server.Plugin {
       this.getLogger(workflow.id).error(`trigger type ${workflow.type} of workflow ${workflow.id} is not implemented`);
       return;
     }
-    if (typeof enable !== "undefined" ? enable : workflow.get("enabled")) {
+    if (enable ?? workflow.get("enabled")) {
       const prev = workflow.previous();
       if (prev.config) {
         trigger.off({ ...workflow.get(), ...prev });
@@ -247,14 +255,18 @@ class WorkflowPlugin extends import_server.Plugin {
     const logger = this.getLogger(workflow.id);
     if (!this.ready) {
       logger.warn(`app is not ready, event of workflow ${workflow.id} will be ignored`);
-      logger.debug(`ignored event data:`, { data: context });
+      logger.debug(`ignored event data:`, context);
       return;
     }
     if (context == null) {
       logger.warn(`workflow ${workflow.id} event data context is null, event will be ignored`);
       return;
     }
-    this.events.push([workflow, context, options]);
+    if (this.isWorkflowSync(workflow)) {
+      return this.triggerSync(workflow, context, options);
+    }
+    const { transaction, ...rest } = options;
+    this.events.push([workflow, context, rest]);
     this.eventsCount = this.events.length;
     logger.info(`new event triggered, now events: ${this.events.length}`);
     logger.debug(`event data:`, {
@@ -265,6 +277,21 @@ class WorkflowPlugin extends import_server.Plugin {
     }
     setTimeout(this.prepare);
   }
+  async triggerSync(workflow, context, options = {}) {
+    let execution;
+    try {
+      execution = await this.createExecution(workflow, context, options);
+    } catch (err) {
+      this.getLogger(workflow.id).error(`creating execution failed: ${err.message}`, err);
+      return null;
+    }
+    try {
+      return this.process(execution, null, options);
+    } catch (err) {
+      this.getLogger(execution.workflowId).error(`execution (${execution.id}) error: ${err.message}`, err);
+    }
+    return null;
+  }
   async resume(job) {
     if (!job.execution) {
       job.execution = await job.getExecution();
@@ -278,52 +305,50 @@ class WorkflowPlugin extends import_server.Plugin {
   createProcessor(execution, options = {}) {
     return new import_Processor.default(execution, { ...options, plugin: this });
   }
-  async createExecution(event) {
-    var _a;
-    const [workflow, context, options] = event;
-    if ((_a = options.context) == null ? void 0 : _a.executionId) {
-      const existed = await workflow.countExecutions({
-        where: {
-          id: options.context.executionId
-        }
-      });
-      if (existed) {
-        this.getLogger(workflow.id).warn(
-          `workflow ${workflow.id} has already been triggered in same execution (${options.context.executionId}), and newly triggering will be skipped.`
-        );
-        return null;
+  async createExecution(workflow, context, options) {
+    const { transaction = await this.db.sequelize.transaction() } = options;
+    const trigger = this.triggers.get(workflow.type);
+    const valid = await trigger.validateEvent(workflow, context, { ...options, transaction });
+    if (!valid) {
+      if (!options.transaction) {
+        await transaction.commit();
       }
+      return null;
     }
-    return this.db.sequelize.transaction(async (transaction) => {
-      const execution = await workflow.createExecution(
-        {
-          context,
-          key: workflow.key,
-          status: import_constants.EXECUTION_STATUS.QUEUEING
+    const execution = await workflow.createExecution(
+      {
+        context,
+        key: workflow.key,
+        status: import_constants.EXECUTION_STATUS.QUEUEING
+      },
+      { transaction }
+    );
+    this.getLogger(workflow.id).info(`execution of workflow ${workflow.id} created as ${execution.id}`);
+    await workflow.increment(["executed", "allExecuted"], { transaction });
+    if (this.db.options.dialect !== "postgres") {
+      await workflow.reload({ transaction });
+    }
+    await workflow.constructor.update(
+      {
+        allExecuted: workflow.allExecuted
+      },
+      {
+        where: {
+          key: workflow.key
         },
-        { transaction }
-      );
-      this.getLogger(workflow.id).info(`execution of workflow ${workflow.id} created as ${execution.id}`);
-      await workflow.increment(["executed", "allExecuted"], { transaction });
-      if (this.db.options.dialect !== "postgres") {
-        await workflow.reload({ transaction });
+        transaction
       }
-      await workflow.constructor.update(
-        {
-          allExecuted: workflow.allExecuted
-        },
-        {
-          where: {
-            key: workflow.key
-          },
-          transaction
-        }
-      );
-      execution.workflow = workflow;
-      return execution;
-    });
+    );
+    if (!options.transaction) {
+      await transaction.commit();
+    }
+    execution.workflow = workflow;
+    return execution;
   }
   prepare = async () => {
+    if (this.executing && this.db.options.dialect === "sqlite") {
+      await this.executing;
+    }
     const event = this.events.shift();
     this.eventsCount = this.events.length;
     if (!event) {
@@ -333,8 +358,8 @@ class WorkflowPlugin extends import_server.Plugin {
     const logger = this.getLogger(event[0].id);
     logger.info(`preparing execution for event`);
     try {
-      const execution = await this.createExecution(event);
-      if (!this.executing && !this.pending.length) {
+      const execution = await this.createExecution(...event);
+      if (execution && !this.executing && !this.pending.length) {
         this.pending.push([execution]);
       }
     } catch (err) {
@@ -355,6 +380,9 @@ class WorkflowPlugin extends import_server.Plugin {
       this.getLogger("dispatcher").warn(`workflow executing is not finished, new dispatching will be ignored`);
       return;
     }
+    if (this.events.length) {
+      return this.prepare();
+    }
     this.executing = (async () => {
       let next = null;
       if (this.pending.length) {
@@ -386,12 +414,12 @@ class WorkflowPlugin extends import_server.Plugin {
       }
     })();
   }
-  async process(execution, job) {
+  async process(execution, job, options = {}) {
     var _a, _b;
     if (execution.status === import_constants.EXECUTION_STATUS.QUEUEING) {
-      await execution.update({ status: import_constants.EXECUTION_STATUS.STARTED });
+      await execution.update({ status: import_constants.EXECUTION_STATUS.STARTED }, { transaction: options.transaction });
     }
-    const processor = this.createProcessor(execution);
+    const processor = this.createProcessor(execution, options);
     this.getLogger(execution.workflowId).info(`execution (${execution.id}) ${job ? "resuming" : "starting"}...`);
     try {
       await (job ? processor.resume(job) : processor.start());
@@ -404,5 +432,6 @@ class WorkflowPlugin extends import_server.Plugin {
     } catch (err) {
       this.getLogger(execution.workflowId).error(`execution (${execution.id}) error: ${err.message}`, err);
     }
+    return processor;
   }
 }

package/dist/server/Processor.d.ts

@@ -1,9 +1,10 @@
-import { Transactionable } from '@nocobase/database';
+import { Transaction, Transactionable } from '@nocobase/database';
 import { Logger } from '@nocobase/logger';
 import type Plugin from './Plugin';
 import type { ExecutionModel, FlowNodeModel, JobModel } from './types';
 export interface ProcessorOptions extends Transactionable {
     plugin: Plugin;
+    [key: string]: any;
 }
 export default class Processor {
     execution: ExecutionModel;
@@ -19,12 +20,14 @@ export default class Processor {
         [-6]: -6;
     };
     logger: Logger;
+    transaction: Transaction;
     nodes: FlowNodeModel[];
     nodesMap: Map<number, FlowNodeModel>;
     jobsMap: Map<number, JobModel>;
     jobsMapByNodeKey: {
         [key: string]: any;
     };
+    lastSavedJob: JobModel | null;
     constructor(execution: ExecutionModel, options: ProcessorOptions);
     private makeNodes;
     private makeJobs;

package/dist/server/Processor.js

@@ -29,6 +29,7 @@ class Processor {
     this.execution = execution;
     this.options = options;
     this.logger = options.plugin.getLogger(execution.workflowId);
+    this.transaction = options.transaction;
   }
   static StatusMap = {
     [import_constants.JOB_STATUS.PENDING]: import_constants.EXECUTION_STATUS.STARTED,
@@ -41,10 +42,12 @@ class Processor {
     [import_constants.JOB_STATUS.RETRY_NEEDED]: import_constants.EXECUTION_STATUS.RETRY_NEEDED
   };
   logger;
+  transaction;
   nodes = [];
   nodesMap = /* @__PURE__ */ new Map();
   jobsMap = /* @__PURE__ */ new Map();
   jobsMapByNodeKey = {};
+  lastSavedJob = null;
   // make dual linked nodes list then cache
   makeNodes(nodes = []) {
     this.nodes = nodes;
@@ -68,14 +71,15 @@ class Processor {
     });
   }
   async prepare() {
-    const { execution } = this;
+    const { execution, transaction } = this;
     if (!execution.workflow) {
-      execution.workflow = await execution.getWorkflow();
+      execution.workflow = await execution.getWorkflow({ transaction });
     }
-    const nodes = await execution.workflow.getNodes();
+    const nodes = await execution.workflow.getNodes({ transaction });
     this.makeNodes(nodes);
     const jobs = await execution.getJobs({
-      order: [["id", "ASC"]]
+      order: [["id", "ASC"]],
+      transaction
     });
     this.makeJobs(jobs);
   }
@@ -116,7 +120,10 @@ class Processor {
         { error: err }
       );
       job = {
-        result: err instanceof Error ? { message: err.message, stack: process.env.NODE_ENV === "production" ? [] : err.stack } : err,
+        result: err instanceof Error ? {
+          message: err.message,
+          stack: process.env.NODE_ENV === "production" ? 'Error stack will not be shown under "production" environment, please check logs.' : err.stack
+        } : err,
         status: import_constants.JOB_STATUS.ERROR
       };
       if (prevJob && prevJob.nodeId === node.id) {
@@ -127,6 +134,7 @@ class Processor {
     if (!(job instanceof import_database.Model)) {
       job.upstreamId = prevJob instanceof import_database.Model ? prevJob.get("id") : null;
       job.nodeId = node.id;
+      job.nodeKey = node.key;
     }
     const savedJob = await this.saveJob(job);
     this.logger.info(
@@ -171,7 +179,7 @@ class Processor {
   async exit(s) {
     if (typeof s === "number") {
       const status = this.constructor.StatusMap[s] ?? Math.sign(s);
-      await this.execution.update({ status });
+      await this.execution.update({ status }, { transaction: this.transaction });
     }
     this.logger.info(`execution (${this.execution.id}) exiting with status ${this.execution.status}`);
     return null;
@@ -179,22 +187,26 @@ class Processor {
   // TODO(optimize)
   async saveJob(payload) {
     const { database } = this.execution.constructor;
+    const { transaction } = this;
     const { model } = database.getCollection("jobs");
     let job;
     if (payload instanceof model) {
-      job = await payload.save();
+      job = await payload.save({ transaction });
     } else if (payload.id) {
-      job = await model.findByPk(payload.id);
-      await job.update(payload);
+      job = await model.findByPk(payload.id, { transaction });
+      await job.update(payload, { transaction });
     } else {
-      job = await model.create({
-        ...payload,
-        executionId: this.execution.id
-      });
+      job = await model.create(
+        {
+          ...payload,
+          executionId: this.execution.id
+        },
+        { transaction }
+      );
     }
     this.jobsMap.set(job.id, job);
-    const node = this.nodesMap.get(job.nodeId);
-    this.jobsMapByNodeKey[node.key] = job.result;
+    this.lastSavedJob = job;
+    this.jobsMapByNodeKey[job.nodeKey] = job.result;
     return job;
   }
   getBranches(node) {

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

@@ -1,2 +1,3 @@
 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>;

package/dist/server/actions/executions.js

@@ -27,6 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var executions_exports = {};
 __export(executions_exports, {
+  cancel: () => cancel,
   destroy: () => destroy
 });
 module.exports = __toCommonJS(executions_exports);
@@ -43,7 +44,44 @@ async function destroy(context, next) {
   });
   await import_actions.default.destroy(context, next);
 }
+async function cancel(context, next) {
+  const { filterByTk } = context.action.params;
+  const ExecutionRepo = context.db.getRepository("executions");
+  const JobRepo = context.db.getRepository("jobs");
+  const execution = await ExecutionRepo.findOne({
+    filterByTk,
+    appends: ["jobs"]
+  });
+  if (!execution) {
+    return context.throw(404);
+  }
+  if (execution.status) {
+    return context.throw(400);
+  }
+  await context.db.sequelize.transaction(async (transaction) => {
+    await execution.update(
+      {
+        status: import_constants.EXECUTION_STATUS.CANCELED
+      },
+      { transaction }
+    );
+    const pendingJobs = execution.jobs.filter((job) => job.status === import_constants.JOB_STATUS.PENDING);
+    await JobRepo.update({
+      values: {
+        status: import_constants.JOB_STATUS.CANCELED
+      },
+      filter: {
+        id: pendingJobs.map((job) => job.id)
+      },
+      individualHooks: false,
+      transaction
+    });
+  });
+  context.body = execution;
+  await next();
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  cancel,
   destroy
 });

package/dist/server/actions/workflows.js

@@ -41,7 +41,7 @@ async function update(context, next) {
   const repository = import_actions.utils.getRepositoryFromParams(context);
   const { filterByTk, values } = context.action.params;
   context.action.mergeParams({
-    whitelist: ["title", "description", "enabled", "config", "options"]
+    whitelist: ["title", "description", "enabled", "triggerTitle", "config", "options"]
   });
   if (Object.keys(values).includes("config")) {
     const workflow = await repository.findById(filterByTk);
@@ -96,7 +96,9 @@ async function revision(context, next) {
     const revisionData = filter.key ? {
       key: filter.key,
       title: origin.title,
-      allExecuted: origin.allExecuted
+      triggerTitle: origin.triggerTitle,
+      allExecuted: origin.allExecuted,
+      sync: origin.sync
     } : values;
     const instance = await repository.create({
       values: {

package/dist/server/collections/executions.js

@@ -21,9 +21,11 @@ __export(executions_exports, {
 });
 module.exports = __toCommonJS(executions_exports);
 var executions_default = {
-  namespace: "workflow.executionLogs",
-  duplicator: "optional",
+  dumpRules: {
+    group: "log"
+  },
   name: "executions",
+  shared: true,
   fields: [
     {
       type: "belongsTo",

package/dist/server/collections/flow_nodes.js

@@ -21,9 +21,9 @@ __export(flow_nodes_exports, {
 });
 module.exports = __toCommonJS(flow_nodes_exports);
 var flow_nodes_default = {
-  namespace: "workflow.workflowConfig",
-  duplicator: "required",
+  dumpRules: "required",
   name: "flow_nodes",
+  shared: true,
   fields: [
     {
       type: "uid",

package/dist/server/collections/jobs.js

@@ -21,9 +21,11 @@ __export(jobs_exports, {
 });
 module.exports = __toCommonJS(jobs_exports);
 var jobs_default = {
-  namespace: "workflow.executionLogs",
-  duplicator: "optional",
+  dumpRules: {
+    group: "log"
+  },
   name: "jobs",
+  shared: true,
   fields: [
     {
       type: "belongsTo",
@@ -34,6 +36,10 @@ var jobs_default = {
       name: "node",
       target: "flow_nodes"
     },
+    {
+      type: "string",
+      name: "nodeKey"
+    },
     {
       type: "belongsTo",
       name: "upstream",

package/dist/server/collections/workflows.js

@@ -22,9 +22,9 @@ __export(workflows_exports, {
 module.exports = __toCommonJS(workflows_exports);
 function workflows_default() {
   return {
-    namespace: "workflow.workflowConfig",
-    duplicator: "required",
+    dumpRules: "required",
     name: "workflows",
+    shared: true,
     fields: [
       {
         name: "key",
@@ -50,7 +50,11 @@ function workflows_default() {
         required: true
       },
       {
-        type: "json",
+        type: "string",
+        name: "triggerTitle"
+      },
+      {
+        type: "jsonb",
         name: "config",
         required: true,
         defaultValue: {}
@@ -81,6 +85,11 @@ function workflows_default() {
         name: "current",
         defaultValue: false
       },
+      {
+        type: "boolean",
+        name: "sync",
+        defaultValue: false
+      },
       {
         type: "hasMany",
         name: "revisions",

package/dist/server/instructions/ConditionInstruction.d.ts

@@ -14,6 +14,7 @@ export declare class ConditionInstruction extends Instruction {
         status: 1;
         result: boolean;
         nodeId: number;
+        nodeKey: any;
         upstreamId: any;
     } | {
         result: any;

package/dist/server/instructions/ConditionInstruction.js

@@ -128,6 +128,7 @@ class ConditionInstruction extends import__.Instruction {
       result,
       // TODO(optimize): try unify the building of job
       nodeId: node.id,
+      nodeKey: node.key,
       upstreamId: prevJob && prevJob.id || null
     };
     const branchNode = processor.nodes.find(

package/dist/server/instructions/CreateInstruction.js

@@ -32,9 +32,9 @@ class CreateInstruction extends import__.Instruction {
     const created = await repository.create({
       ...options,
       context: {
-        executionId: processor.execution.id
-      }
-      // transaction: processor.transaction,
+        stack: Array.from(new Set((processor.execution.context.stack ?? []).concat(processor.execution.id)))
+      },
+      transaction: processor.transaction
     });
     let result = created;
     if (created && appends.length) {
@@ -45,8 +45,8 @@ class CreateInstruction extends import__.Instruction {
       }, /* @__PURE__ */ new Set());
       result = await repository.findOne({
         filterByTk: created[model.primaryKeyAttribute],
-        appends: Array.from(includeFields)
-        // transaction: processor.transaction,
+        appends: Array.from(includeFields),
+        transaction: processor.transaction
       });
     }
     return {

package/dist/server/instructions/DestroyInstruction.js

@@ -31,9 +31,9 @@ class DestroyInstruction extends import__.Instruction {
     const result = await repo.destroy({
       ...options,
       context: {
-        executionId: processor.execution.id
-      }
-      // transaction: processor.transaction,
+        stack: Array.from(new Set((processor.execution.context.stack ?? []).concat(processor.execution.id)))
+      },
+      transaction: processor.transaction
     });
     return {
       result,

package/dist/server/instructions/EndInstruction.d.ts

@@ -0,0 +1,6 @@
+import Instruction from '.';
+import Processor from '../Processor';
+import { FlowNodeModel } from '../types';
+export default class extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<any>;
+}

package/dist/server/instructions/EndInstruction.js

@@ -0,0 +1,46 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EndInstruction_exports = {};
+__export(EndInstruction_exports, {
+  default: () => EndInstruction_default
+});
+module.exports = __toCommonJS(EndInstruction_exports);
+var import__ = __toESM(require("."));
+var import_constants = require("../constants");
+class EndInstruction_default extends import__.default {
+  async run(node, prevJob, processor) {
+    const { endStatus = import_constants.JOB_STATUS.RESOLVED } = node.config;
+    await processor.saveJob({
+      status: endStatus,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    return processor.exit(endStatus);
+  }
+}