@nocobase/plugin-workflow 2.2.0-alpha.1 → 2.2.0-alpha.10

package/dist/server/Plugin.js

@@ -53,6 +53,7 @@ var import_RunningExecutionRegistry = __toESM(require("./RunningExecutionRegistr
 var import_actions = __toESM(require("./actions"));
 var import_nodes = require("./actions/nodes");
 var import_workflows = require("./actions/workflows");
+var import_constants = require("./constants");
 var import_functions = __toESM(require("./functions"));
 var import_CollectionTrigger = __toESM(require("./triggers/CollectionTrigger"));
 var import_ScheduleTrigger = __toESM(require("./triggers/ScheduleTrigger"));
@@ -170,16 +171,16 @@ class PluginWorkflowServer extends import_server.Plugin {
       }
     }
     this.checker = setInterval(() => {
-      this.dispatcher.dispatch();
+      this.dispatcher.recover({ gracePeriod: 6e4 });
     }, 3e5);
     await this.timeoutManager.load();
-    this.app.on("workflow:dispatch", () => {
-      this.app.logger.info("workflow:dispatch");
-      this.dispatcher.dispatch();
+    this.app.on("workflow:recover", () => {
+      this.app.logger.info("workflow:recover");
+      this.dispatcher.recover();
     });
     this.dispatcher.setReady(true);
     this.getLogger("dispatcher").info("(starting) check for queueing executions");
-    this.dispatcher.dispatch();
+    this.dispatcher.recover();
   };
   onBeforeStop = async () => {
     if (this.checker) {
@@ -191,7 +192,6 @@ class PluginWorkflowServer extends import_server.Plugin {
     for (const workflow of this.enabledCache.values()) {
       this.toggle(workflow, false, { silent: true });
     }
-    this.app.eventQueue.unsubscribe(this.channelPendingExecution);
     this.loggerCache.clear();
   };
   async handleSyncMessage(message) {
@@ -401,7 +401,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     this.app.on("beforeStop", this.onBeforeStop);
     this.app.eventQueue.subscribe(this.channelPendingExecution, {
       idle: () => this.serving() && this.dispatcher.idle,
-      process: this.dispatcher.onQueueExecution
+      process: this.dispatcher.onQueueTask
     });
   }
   toggle(workflow, enable, { silent, transaction } = {}) {
@@ -448,25 +448,70 @@ class PluginWorkflowServer extends import_server.Plugin {
   trigger(workflow, context, options = {}) {
     return this.dispatcher.trigger(workflow, context, options);
   }
-  async run(pending) {
-    return this.dispatcher.run(pending);
+  async rerun(execution, rerun) {
+    return this.dispatcher.enqueue({ executionId: this.getModelId(execution), rerun: rerun ?? {} });
   }
-  dispatch() {
-    return this.dispatcher.dispatch();
+  recover() {
+    return this.dispatcher.recover();
   }
+  /**
+   * Persist the current job state and publish a poke that evaluates that state.
+   *
+   * PENDING resume calls are valid for instructions such as delay and sequential approval.
+   * Callers that aggregate multiple user actions must only call this method when their
+   * atomic update changes the job from PENDING to a terminal status.
+   * Persistence and queue publication failures are logged and rethrown to awaiting callers.
+   */
   async resume(job) {
-    return this.dispatcher.resume(job);
+    var _a;
+    const executionId = job.executionId ?? ((_a = job.execution) == null ? void 0 : _a.id);
+    if (executionId == null) {
+      this.getLogger("dispatcher").warn(`execution id of job (${job.id}) not found, resume ignored`);
+      return;
+    }
+    try {
+      if (job.changed()) {
+        await job.save();
+      }
+    } catch (error) {
+      this.getLogger("dispatcher").error(
+        `persisting job (${job.id}) before resuming execution (${executionId}) failed`,
+        { error, executionId, jobId: job.id }
+      );
+      throw error;
+    }
+    try {
+      await this.dispatcher.enqueue({ executionId, jobId: job.id });
+      this.getLogger("dispatcher").info(`execution (${executionId}) resuming from job (${job.id}) published to queue`);
+    } catch (error) {
+      this.getLogger("dispatcher").error(
+        `publishing resume task for execution (${executionId}) from job (${job.id}) failed`,
+        { error, executionId, jobId: job.id }
+      );
+      throw error;
+    }
   }
   /**
    * Start a deferred execution
    * @experimental
    */
   async start(execution) {
-    return this.dispatcher.start(execution);
+    if (typeof execution !== "string" && typeof execution !== "number") {
+      if (execution.status !== import_constants.EXECUTION_STATUS.QUEUEING && execution.status !== import_constants.EXECUTION_STATUS.STARTED && execution.status != null) {
+        return;
+      }
+      if (execution.status === import_constants.EXECUTION_STATUS.STARTED && execution.startedAt) {
+        return;
+      }
+    }
+    return this.dispatcher.enqueue({ executionId: this.getModelId(execution) });
   }
   createProcessor(execution, options = {}) {
     return new import_Processor.default(execution, { ...options, plugin: this });
   }
+  getModelId(input) {
+    return typeof input === "string" || typeof input === "number" ? input : input.id;
+  }
   async execute(workflow, values, options = {}) {
     const trigger = this.triggers.get(workflow.type);
     if (!trigger) {

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
@@ -94,13 +101,7 @@ export default class Processor {
     prepare(): Promise<void>;
     start(): Promise<any>;
     resume(job: JobModel): Promise<void>;
-    resolveRerun(options?: ProcessorRerunOptions): {
-        node: FlowNodeModel;
-        input: JobModel | {
-            result: any;
-        };
-        targetJob: JobModel;
-    };
+    private resolveRerun;
     rerun(options?: ProcessorRerunOptions): Promise<any>;
     private getRerunNode;
     private getRerunInput;
@@ -111,6 +112,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/executions.js

@@ -98,12 +98,9 @@ async function rerun(context, next) {
   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
-    }
+  await workflowPlugin.rerun(execution, {
+    nodeId,
+    overwrite: overwrite === true
   });
   context.body = execution;
   context.status = 202;

package/dist/server/actions/jobs.js

@@ -82,8 +82,7 @@ async function resume(context, next) {
   context.body = job;
   context.status = 202;
   await next();
-  job.execution = execution;
-  workflowPlugin.resume(job);
+  await workflowPlugin.resume(job);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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/actions/workflows.d.ts

@@ -12,6 +12,7 @@ export declare class WorkflowValidationError extends Error {
     errors: Record<string, string>;
     constructor(errors: Record<string, string>);
 }
+export declare function list(context: Context, next: any): Promise<void>;
 export declare function create(context: Context, next: any): Promise<void>;
 export declare function update(context: Context, next: any): Promise<void>;
 export declare function destroy(context: Context, next: any): Promise<void>;

package/dist/server/actions/workflows.js

@@ -40,6 +40,7 @@ __export(workflows_exports, {
   create: () => create,
   destroy: () => destroy,
   execute: () => execute,
+  list: () => list,
   revision: () => revision,
   sync: () => sync,
   update: () => update
@@ -72,9 +73,14 @@ function validateWorkflow(context, plugin, { type, config }) {
     }
   }
 }
+async function list(context, next) {
+  return import_actions.default.list(context, next);
+}
 async function create(context, next) {
   const plugin = context.app.pm.get(import_Plugin.default);
-  const { values } = context.action.params;
+  const values = { ...context.action.params.values || {} };
+  delete values.invalid;
+  context.action.mergeParams({ values }, { values: "overwrite" });
   validateWorkflow(context, plugin, values);
   return import_actions.default.create(context, next);
 }
@@ -139,10 +145,12 @@ async function destroy(context, next) {
 async function revision(context, next) {
   const repository = import_actions.utils.getRepositoryFromParams(context);
   const { filterByTk, filter = {}, values = {} } = context.action.params;
+  const revisionValues = { ...values };
+  delete revisionValues.invalid;
   context.body = await repository.revision({
     filterByTk,
     filter,
-    values,
+    values: revisionValues,
     context
   });
   await next();
@@ -184,6 +192,12 @@ async function execute(context, next) {
   let processor;
   try {
     processor = await plugin.execute(workflow, values, { manually: true });
+    if (processor === null) {
+      context.body = {
+        execution: null
+      };
+      return next();
+    }
     if (!processor) {
       return context.throw(400, "workflow not triggered");
     }
@@ -220,6 +234,7 @@ async function execute(context, next) {
   create,
   destroy,
   execute,
+  list,
   revision,
   sync,
   update

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 {

package/dist/server/instructions/UpdateInstruction.js

@@ -66,12 +66,13 @@ class UpdateInstruction 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.update({
       ...options,
       context: {
         stack: Array.from(new Set((processor.execution.stack ?? []).concat(processor.execution.id)))
       },
-      transaction: this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction)
+      transaction
     });
     return {
       result: result.length ?? result,

package/dist/server/triggers/CollectionTrigger.d.ts

@@ -15,6 +15,7 @@ import PluginWorkflowServer from '../Plugin';
 export interface CollectionChangeTriggerConfig {
     collection: string;
     mode: number;
+    rollbackOnFailure?: boolean;
     condition: any;
 }
 export default class CollectionTrigger extends Trigger {
@@ -24,8 +25,12 @@ export default class CollectionTrigger extends Trigger {
     events: Map<any, any>;
     constructor(workflow: PluginWorkflowServer);
     private static handler;
+    createRollbackOnFailureError(locale?: string): Error & {
+        status?: number;
+        code?: string;
+    };
     prepare(workflow: WorkflowModel, data: Model | Record<string, any> | string | number, options: any): Promise<{
-        data: any;
+        data: string | number | Record<string, any> | Model<any, any>;
     }>;
     on(workflow: WorkflowModel): void;
     off(workflow: WorkflowModel): void;