@nocobase/plugin-workflow 2.1.0-alpha.4 → 2.1.0-alpha.45

package/dist/server/utils.d.ts

@@ -6,4 +6,31 @@
  * 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 { Transactionable } from '@nocobase/database';
+import type { DataSourceManager } from '@nocobase/data-source-manager';
+import type PluginWorkflowServer from './Plugin';
+import { EXECUTION_REASON } from './constants';
+import type { ExecutionModel, WorkflowModel } from './types';
+import Processor from './Processor';
+type AbortOptions = Transactionable & {
+    reason?: (typeof EXECUTION_REASON)[keyof typeof EXECUTION_REASON];
+};
+export declare function getExecutionLockKey(executionId: number | string): string;
+export declare function isLockAcquireError(error: unknown): boolean;
+export declare function validateCollectionField(collection: string, dataSourceManager: DataSourceManager): Record<string, string> | null;
+export declare function getExecutionStatusName(status: number | null | undefined): string;
+export declare function getWorkflowExecutionLogMeta(workflow: WorkflowModel, processor?: Processor): {
+    workflowId: number;
+    workflowKey: string;
+    workflowTitle: string;
+    executionId: number;
+    executionStatus: number;
+    executionStatusName: string;
+    lastNodeId: number;
+    lastNodeType: string;
+    lastJobId: number;
+    lastJobStatus: number;
+};
+export declare function abortExecution(plugin: PluginWorkflowServer, execution: ExecutionModel, options?: AbortOptions): Promise<boolean>;
 export declare function toJSON(data: any): any;
+export {};

package/dist/server/utils.js

@@ -26,10 +26,140 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
-  toJSON: () => toJSON
+  abortExecution: () => abortExecution,
+  getExecutionLockKey: () => getExecutionLockKey,
+  getExecutionStatusName: () => getExecutionStatusName,
+  getWorkflowExecutionLogMeta: () => getWorkflowExecutionLogMeta,
+  isLockAcquireError: () => isLockAcquireError,
+  toJSON: () => toJSON,
+  validateCollectionField: () => validateCollectionField
 });
 module.exports = __toCommonJS(utils_exports);
 var import_database = require("@nocobase/database");
+var import_data_source_manager = require("@nocobase/data-source-manager");
+var import_constants = require("./constants");
+function getExecutionLockKey(executionId) {
+  return `workflow:execution:${executionId}`;
+}
+function isLockAcquireError(error) {
+  return error instanceof Error && error.constructor.name === "LockAcquireError";
+}
+function afterTransactionCommit(transaction, callback) {
+  if (typeof transaction.afterCommit === "function") {
+    transaction.afterCommit(callback);
+    return;
+  }
+  callback();
+}
+function validateCollectionField(collection, dataSourceManager) {
+  const [dataSourceName, collectionName] = (0, import_data_source_manager.parseCollectionName)(collection);
+  if (!dataSourceName || !collectionName) {
+    return { collection: `"collection" must be in the format "dataSourceName:collectionName"` };
+  }
+  const dataSource = dataSourceManager.dataSources.get(dataSourceName);
+  if (!dataSource) {
+    return { collection: `Data source "${dataSourceName}" does not exist` };
+  }
+  if (!dataSource.collectionManager.getCollection(collectionName)) {
+    return { collection: `Collection "${collectionName}" does not exist in data source "${dataSourceName}"` };
+  }
+  return null;
+}
+const EXECUTION_STATUS_NAMES = new Map(Object.entries(import_constants.EXECUTION_STATUS).map(([name, value]) => [value, name]));
+function getExecutionStatusName(status) {
+  if (typeof status === "undefined") {
+    return "UNKNOWN";
+  }
+  return EXECUTION_STATUS_NAMES.get(status) ?? `${status}`;
+}
+function getWorkflowExecutionLogMeta(workflow, processor) {
+  var _a, _b, _c, _d;
+  const lastSavedJob = processor == null ? void 0 : processor.lastSavedJob;
+  const lastNode = (_a = processor == null ? void 0 : processor.nodesMap) == null ? void 0 : _a.get(lastSavedJob == null ? void 0 : lastSavedJob.nodeId);
+  return {
+    workflowId: workflow.id,
+    workflowKey: workflow.key,
+    workflowTitle: workflow.title,
+    executionId: ((_b = processor == null ? void 0 : processor.execution) == null ? void 0 : _b.id) ?? null,
+    executionStatus: ((_c = processor == null ? void 0 : processor.execution) == null ? void 0 : _c.status) ?? null,
+    executionStatusName: getExecutionStatusName((_d = processor == null ? void 0 : processor.execution) == null ? void 0 : _d.status),
+    lastNodeId: (lastNode == null ? void 0 : lastNode.id) ?? (lastSavedJob == null ? void 0 : lastSavedJob.nodeId) ?? null,
+    lastNodeType: (lastNode == null ? void 0 : lastNode.type) ?? null,
+    lastJobId: (lastSavedJob == null ? void 0 : lastSavedJob.id) ?? null,
+    lastJobStatus: (lastSavedJob == null ? void 0 : lastSavedJob.status) ?? null
+  };
+}
+async function abortExecution(plugin, execution, options = {}) {
+  const logger = plugin.getLogger(execution.workflowId);
+  const ownTransaction = !options.transaction;
+  const transaction = options.transaction ?? await plugin.useDataSourceTransaction("main", null, true);
+  const ExecutionRepo = plugin.db.getRepository("executions");
+  const JobRepo = plugin.db.getRepository("jobs");
+  try {
+    const lockedExecution = await ExecutionRepo.findOne({
+      filterByTk: execution.id,
+      transaction,
+      lock: transaction.LOCK.UPDATE
+    });
+    if (!lockedExecution || lockedExecution.status !== import_constants.EXECUTION_STATUS.STARTED) {
+      if (ownTransaction) {
+        await transaction.commit();
+      }
+      return false;
+    }
+    await lockedExecution.update(
+      {
+        status: import_constants.EXECUTION_STATUS.ABORTED,
+        ...options.reason ? {
+          reason: options.reason
+        } : {}
+      },
+      {
+        transaction
+      }
+    );
+    const updated = await JobRepo.update({
+      values: {
+        status: import_constants.JOB_STATUS.ABORTED
+      },
+      filter: {
+        executionId: execution.id,
+        status: import_constants.JOB_STATUS.PENDING
+      },
+      individualHooks: false,
+      transaction
+    });
+    const childExecutions = await plugin.db.getRepository("executions").find({
+      filter: {
+        parentExecutionId: execution.id,
+        status: import_constants.EXECUTION_STATUS.STARTED
+      },
+      transaction
+    });
+    for (const child of childExecutions) {
+      await abortExecution(plugin, child, { transaction, reason: import_constants.EXECUTION_REASON.PARENT_ABORTED });
+    }
+    afterTransactionCommit(transaction, () => {
+      execution.set("status", import_constants.EXECUTION_STATUS.ABORTED);
+      execution.set("reason", options.reason ?? null);
+      plugin.timeoutManager.clear(execution.id);
+      plugin.abortRunningExecution(execution.id, options.reason);
+    });
+    logger.info(`execution (${execution.id}) aborted`, {
+      workflowId: execution.workflowId,
+      pendingJobs: Array.isArray(updated) ? updated.length : updated
+    });
+    if (ownTransaction) {
+      await transaction.commit();
+    }
+    return true;
+  } catch (error) {
+    if (ownTransaction && !transaction.finished) {
+      await transaction.rollback();
+    }
+    throw error;
+  }
+}
 function toJSON(data) {
   if (Array.isArray(data)) {
     return data.map(toJSON);
@@ -47,5 +177,11 @@ function toJSON(data) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  toJSON
+  abortExecution,
+  getExecutionLockKey,
+  getExecutionStatusName,
+  getWorkflowExecutionLogMeta,
+  isLockAcquireError,
+  toJSON,
+  validateCollectionField
 });