@nocobase/plugin-workflow-javascript 2.3.0-alpha.1 → 2.3.0-beta.11

package/dist/server/RunningJobs.js

@@ -0,0 +1,105 @@
+/**
+ * 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 RunningJobs_exports = {};
+__export(RunningJobs_exports, {
+  ABORT_JAVASCRIPT_JOB_SYNC_MESSAGE_TYPE: () => ABORT_JAVASCRIPT_JOB_SYNC_MESSAGE_TYPE,
+  JAVASCRIPT_SYNC_MESSAGE_CHANNEL: () => JAVASCRIPT_SYNC_MESSAGE_CHANNEL,
+  RunningJobs: () => RunningJobs,
+  getAbortReason: () => getAbortReason
+});
+module.exports = __toCommonJS(RunningJobs_exports);
+const JAVASCRIPT_SYNC_MESSAGE_CHANNEL = "@nocobase/plugin-workflow-javascript";
+const ABORT_JAVASCRIPT_JOB_SYNC_MESSAGE_TYPE = "abortJavaScriptJob";
+function getAbortReason(reason) {
+  if (reason instanceof Error) {
+    return reason.message;
+  }
+  if (typeof reason === "string") {
+    return reason;
+  }
+  return void 0;
+}
+class RunningJobs {
+  jobs = /* @__PURE__ */ new Map();
+  executionJobs = /* @__PURE__ */ new Map();
+  register(job) {
+    const jobId = String(job.jobId);
+    const executionId = String(job.executionId);
+    const executionJobs = this.executionJobs.get(executionId) ?? /* @__PURE__ */ new Set();
+    this.jobs.set(jobId, job);
+    executionJobs.add(jobId);
+    this.executionJobs.set(executionId, executionJobs);
+    return () => this.unregister(job.jobId);
+  }
+  unregister(jobId) {
+    const key = String(jobId);
+    const job = this.jobs.get(key);
+    if (!job) {
+      return;
+    }
+    this.jobs.delete(key);
+    const executionId = String(job.executionId);
+    const executionJobs = this.executionJobs.get(executionId);
+    executionJobs == null ? void 0 : executionJobs.delete(key);
+    if (!(executionJobs == null ? void 0 : executionJobs.size)) {
+      this.executionJobs.delete(executionId);
+    }
+  }
+  abortJob(jobId, reason) {
+    const job = this.jobs.get(String(jobId));
+    if (!job) {
+      return false;
+    }
+    job.abort(reason);
+    return true;
+  }
+  abortExecution(executionId, reason) {
+    var _a;
+    const jobIds = this.executionJobs.get(String(executionId));
+    if (!(jobIds == null ? void 0 : jobIds.size)) {
+      return false;
+    }
+    for (const jobId of jobIds) {
+      (_a = this.jobs.get(jobId)) == null ? void 0 : _a.abort(reason);
+    }
+    return true;
+  }
+  async abortAcrossInstances(workflowPlugin, message) {
+    if (this.abortJob(message.jobId, message.reason)) {
+      return true;
+    }
+    await workflowPlugin.app.syncMessageManager.publish(JAVASCRIPT_SYNC_MESSAGE_CHANNEL, message);
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ABORT_JAVASCRIPT_JOB_SYNC_MESSAGE_TYPE,
+  JAVASCRIPT_SYNC_MESSAGE_CHANNEL,
+  RunningJobs,
+  getAbortReason
+});

package/dist/server/ScriptInstruction.d.ts

@@ -8,7 +8,9 @@
  */
 import { Logger } from 'winston';
 import Joi from 'joi';
-import { Processor, Instruction, FlowNodeModel } from '@nocobase/plugin-workflow';
+import WorkflowPlugin, { Processor, Instruction, FlowNodeModel } from '@nocobase/plugin-workflow';
+import { RunningJobs } from './RunningJobs';
+import { ScriptArguments, ScriptRunResult } from './ScriptWorkerRunner';
 type ScriptArgument = {
     name: string;
     value?: unknown;
@@ -19,41 +21,27 @@ type ScriptConfig = {
     continue?: boolean;
     arguments?: ScriptArgument[];
 };
-type ScriptArguments = Record<string, unknown> | unknown[];
 export default class ScriptInstruction extends Instruction {
-    /**
-     * Returns the worker script path based on whether WORKFLOW_SCRIPT_MODULES is configured.
-     * - WORKFLOW_SCRIPT_MODULES set: uses Node.js vm with require support (unsafe; not a security boundary)
-     * - WORKFLOW_SCRIPT_MODULES unset: uses QuickJS (WASM) for maximum security (no require, no Node.js APIs)
-     */
+    private readonly runningJobs;
     static get workerScript(): string;
     static run(source: string, args: ScriptArguments, options: {
         logger: Logger;
         timeout?: number;
         signal?: AbortSignal;
-    }): Promise<{
-        status: -2;
-        result: string;
-    } | {
-        status: 1;
-        result: unknown;
-    }>;
+    }): Promise<ScriptRunResult>;
+    constructor(workflow: WorkflowPlugin, runningJobs: RunningJobs);
     configSchema: Joi.ObjectSchema<any>;
     run(node: FlowNodeModel, prevJob: any, processor: Processor, options?: {
         signal?: AbortSignal;
     }): Promise<{
         result: unknown;
-        status: -2 | 1;
+        status: 1 | -2;
     }>;
     resume(node: FlowNodeModel, job: any, processor: Processor): Promise<any>;
     test(config?: ScriptConfig): Promise<{
         log: string;
-        status: -2;
-        result: string;
-    } | {
-        log: string;
-        status: 1;
-        result: unknown;
+        status: number;
+        result?: unknown;
     }>;
 }
 export {};

package/dist/server/ScriptInstruction.js

@@ -39,76 +39,23 @@ __export(ScriptInstruction_exports, {
   default: () => ScriptInstruction
 });
 module.exports = __toCommonJS(ScriptInstruction_exports);
-var import_node_events = require("node:events");
-var import_node_path = __toESM(require("node:path"));
-var import_node_worker_threads = require("node:worker_threads");
 var import_winston = __toESM(require("winston"));
 var import_joi = __toESM(require("joi"));
 var import_plugin_workflow = require("@nocobase/plugin-workflow");
 var import_cache_logger = require("./cache-logger");
+var import_constants = require("./constants");
+var import_RunningJobs = require("./RunningJobs");
+var import_ScriptWorkerRunner = require("./ScriptWorkerRunner");
 class ScriptInstruction extends import_plugin_workflow.Instruction {
-  /**
-   * Returns the worker script path based on whether WORKFLOW_SCRIPT_MODULES is configured.
-   * - WORKFLOW_SCRIPT_MODULES set: uses Node.js vm with require support (unsafe; not a security boundary)
-   * - WORKFLOW_SCRIPT_MODULES unset: uses QuickJS (WASM) for maximum security (no require, no Node.js APIs)
-   */
+  constructor(workflow, runningJobs) {
+    super(workflow);
+    this.runningJobs = runningJobs;
+  }
   static get workerScript() {
-    const hasModules = (process.env.WORKFLOW_SCRIPT_MODULES ?? "").split(",").filter(Boolean).length > 0;
-    return import_node_path.default.join(__dirname, hasModules ? "Vm.js" : "QuickJs.js");
+    return import_ScriptWorkerRunner.ScriptWorkerRunner.workerScript;
   }
   static async run(source, args, options) {
-    const { logger, timeout, signal } = options;
-    let result;
-    const worker = new import_node_worker_threads.Worker(this.workerScript, {
-      workerData: { source, args, options: timeout ? { timeout } : {} }
-    });
-    const abortListener = () => {
-      worker.terminate();
-    };
-    signal == null ? void 0 : signal.addEventListener("abort", abortListener, { once: true });
-    worker.on("message", (message) => {
-      if (message.type === "result") {
-        result = message.result;
-      }
-    });
-    worker.stdout.on("data", (data) => {
-      logger.info(data.toString());
-    });
-    worker.stderr.on("data", (data) => {
-      logger.error(data.toString());
-    });
-    const excution = new Promise((resolve, reject) => {
-      worker.on("error", (error) => {
-        reject(error);
-      });
-      const stdoutPromise = (0, import_node_events.once)(worker.stdout, "close");
-      const stderrPromise = (0, import_node_events.once)(worker.stderr, "close");
-      worker.on("exit", (code) => {
-        Promise.all([stdoutPromise, stderrPromise]).then(() => {
-          if (code !== 0) {
-            reject(new Error(`Worker stopped with exit code ${code}`));
-          }
-          resolve(result);
-        }).catch(reject);
-      });
-    });
-    try {
-      await excution;
-    } catch (e) {
-      signal == null ? void 0 : signal.removeEventListener("abort", abortListener);
-      if (signal == null ? void 0 : signal.aborted) {
-        throw signal.reason instanceof Error ? signal.reason : new import_plugin_workflow.WorkflowTimeoutError();
-      }
-      return {
-        status: import_plugin_workflow.JOB_STATUS.ERROR,
-        result: e instanceof Error ? e.message : String(e)
-      };
-    }
-    signal == null ? void 0 : signal.removeEventListener("abort", abortListener);
-    return {
-      status: import_plugin_workflow.JOB_STATUS.RESOLVED,
-      result
-    };
+    return import_ScriptWorkerRunner.ScriptWorkerRunner.run(source, args, options);
   }
   configSchema = import_joi.default.object({
     content: import_joi.default.string(),
@@ -122,6 +69,7 @@ class ScriptInstruction extends import_plugin_workflow.Instruction {
     ).optional()
   });
   async run(node, prevJob, processor, options) {
+    var _a, _b;
     const { content = "", continue: cont, timeout } = node.config;
     const args = processor.getParsedValue(node.config.arguments ?? [], node.id);
     const _args = args.reduce((pre, item) => ({ ...pre, [item.name]: item.value }), {});
@@ -143,53 +91,48 @@ class ScriptInstruction extends import_plugin_workflow.Instruction {
         status: cont ? import_plugin_workflow.JOB_STATUS.RESOLVED : result.status === import_plugin_workflow.JOB_STATUS.RESOLVED ? import_plugin_workflow.JOB_STATUS.RESOLVED : import_plugin_workflow.JOB_STATUS.ERROR
       };
     }
+    const meta = {
+      args: _args
+    };
     const { id } = processor.saveJob({
       status: import_plugin_workflow.JOB_STATUS.PENDING,
       nodeId: node.id,
       nodeKey: node.key,
-      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null,
+      startedAt: null,
+      meta
     });
-    processor.logger.info(`script (#${node.id}) has been started, waiting for response...`);
-    await processor.exit();
-    const jobResult = {
-      status: import_plugin_workflow.JOB_STATUS.PENDING
+    const abortQueuedJob = async () => {
+      var _a2;
+      await this.runningJobs.abortAcrossInstances(this.workflow, {
+        type: import_RunningJobs.ABORT_JAVASCRIPT_JOB_SYNC_MESSAGE_TYPE,
+        jobId: id,
+        executionId: processor.execution.id,
+        reason: (0, import_RunningJobs.getAbortReason)((_a2 = options == null ? void 0 : options.signal) == null ? void 0 : _a2.reason)
+      });
     };
-    this.constructor.run(content, _args, { timeout, logger: processor.logger, signal: options == null ? void 0 : options.signal }).then((res) => {
-      if (res.status === import_plugin_workflow.JOB_STATUS.RESOLVED) {
-        processor.logger.info(`script (#${node.id}) get result success`);
-        jobResult.status = import_plugin_workflow.JOB_STATUS.RESOLVED;
-        jobResult.result = res.result;
-        processor.logger.info(`run script execution success, node id: ${node.id},the result is ${res.result}`);
-        return;
-      }
-      if (cont) {
-        processor.logger.warn(`script (#${node.id}) get result failed, the reason is ${res.result}`);
-        jobResult.status = import_plugin_workflow.JOB_STATUS.RESOLVED;
-        jobResult.result = res.result;
-        return;
-      }
-      processor.logger.info(`script (#${node.id}) get result failed, the reason is ${res.result}`);
-      jobResult.status = import_plugin_workflow.JOB_STATUS.ERROR;
-      jobResult.result = res.result;
-    }).catch((e) => {
-      const message = e instanceof Error ? e.message : String(e);
-      processor.logger.error(`script (#${node.id}) get result failed, the reason is ${message}`);
-      jobResult.status = import_plugin_workflow.JOB_STATUS.ERROR;
-      jobResult.result = message;
-    }).finally(() => {
-      processor.logger.debug(`script (#${node.id}) ended, resume workflow...`);
-      setImmediate(async () => {
-        const job = await this.workflow.db.getRepository("jobs").findOne({ filterByTk: id });
-        const execution = await job.getExecution();
-        if (execution.status !== 0) {
-          processor.logger.warn(`script (#${node.id}) result discarded because execution (${execution.id}) is ended`);
-          return;
-        }
-        job.set(jobResult);
-        job.execution = execution;
-        this.workflow.resume(job);
+    if ((_a = options == null ? void 0 : options.signal) == null ? void 0 : _a.aborted) {
+      await abortQueuedJob();
+    } else {
+      (_b = options == null ? void 0 : options.signal) == null ? void 0 : _b.addEventListener(
+        "abort",
+        () => {
+          abortQueuedJob().catch((error) => {
+            processor.logger.error(`broadcasting JavaScript job (${id}) abort signal failed`, { error });
+          });
+        },
+        { once: true }
+      );
+    }
+    processor.logger.info(`script (#${node.id}) has been queued, waiting for JavaScript Worker resource...`);
+    await processor.exit();
+    try {
+      await this.workflow.app.eventQueue.publish(import_constants.PENDING_JAVASCRIPT_TASK_CHANNEL, {
+        jobId: id
       });
-    });
+    } catch (error) {
+      processor.logger.error(`publishing JavaScript job (${id}) failed, recovery will republish it`, { error });
+    }
   }
   async resume(node, job, processor) {
     return job;

package/dist/server/ScriptWorkerRunner.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+import { Logger } from 'winston';
+export type ScriptArguments = Record<string, unknown> | unknown[] | null;
+export type ScriptRunResult = {
+    status: number;
+    result?: unknown;
+};
+export declare class ScriptWorkerRunner {
+    /**
+     * Returns the worker script path based on whether WORKFLOW_SCRIPT_MODULES is configured.
+     * - WORKFLOW_SCRIPT_MODULES set: uses Node.js vm with require support (unsafe; not a security boundary)
+     * - WORKFLOW_SCRIPT_MODULES unset: uses QuickJS (WASM) for maximum security (no require, no Node.js APIs)
+     */
+    static get workerScript(): string;
+    static run(source: string, args: ScriptArguments, options: {
+        logger: Logger;
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<ScriptRunResult>;
+}

package/dist/server/ScriptWorkerRunner.js

@@ -0,0 +1,140 @@
+/**
+ * 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 __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 ScriptWorkerRunner_exports = {};
+__export(ScriptWorkerRunner_exports, {
+  ScriptWorkerRunner: () => ScriptWorkerRunner
+});
+module.exports = __toCommonJS(ScriptWorkerRunner_exports);
+var import_node_events = require("node:events");
+var import_node_path = __toESM(require("node:path"));
+var import_node_worker_threads = require("node:worker_threads");
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+function isWorkerResult(message) {
+  return typeof message === "object" && message !== null && "type" in message && message.type === "result";
+}
+class ScriptWorkerRunner {
+  /**
+   * Returns the worker script path based on whether WORKFLOW_SCRIPT_MODULES is configured.
+   * - WORKFLOW_SCRIPT_MODULES set: uses Node.js vm with require support (unsafe; not a security boundary)
+   * - WORKFLOW_SCRIPT_MODULES unset: uses QuickJS (WASM) for maximum security (no require, no Node.js APIs)
+   */
+  static get workerScript() {
+    const hasModules = (process.env.WORKFLOW_SCRIPT_MODULES ?? "").split(",").filter(Boolean).length > 0;
+    return import_node_path.default.join(__dirname, hasModules ? "Vm.js" : "QuickJs.js");
+  }
+  static async run(source, args, options) {
+    const { logger, timeout, signal } = options;
+    const worker = new import_node_worker_threads.Worker(this.workerScript, {
+      workerData: { source, args, options: timeout ? { timeout } : {} }
+    });
+    worker.stdout.on("data", (data) => {
+      logger.info(data.toString());
+    });
+    worker.stderr.on("data", (data) => {
+      logger.error(data.toString());
+    });
+    const outputClosed = Promise.all([(0, import_node_events.once)(worker.stdout, "close"), (0, import_node_events.once)(worker.stderr, "close")]);
+    const outcomePromise = new Promise((resolve) => {
+      const finish = (outcome2) => {
+        worker.removeListener("message", messageListener);
+        worker.removeListener("error", errorListener);
+        worker.removeListener("exit", exitListener);
+        signal == null ? void 0 : signal.removeEventListener("abort", abortListener);
+        resolve(outcome2);
+      };
+      const messageListener = (message) => {
+        if (isWorkerResult(message)) {
+          finish({ type: "result", result: message.result });
+        }
+      };
+      const errorListener = (error) => {
+        finish({ type: "error", error });
+      };
+      const exitListener = (code) => {
+        finish({ type: "exit", code });
+      };
+      const abortListener = () => {
+        finish({ type: "aborted" });
+      };
+      worker.on("message", messageListener);
+      worker.once("error", errorListener);
+      worker.once("exit", exitListener);
+      signal == null ? void 0 : signal.addEventListener("abort", abortListener, { once: true });
+      if (signal == null ? void 0 : signal.aborted) {
+        abortListener();
+      }
+    });
+    const outcome = await outcomePromise;
+    try {
+      if (outcome.type !== "exit") {
+        await worker.terminate();
+      }
+      await outputClosed;
+    } catch (error) {
+      if (outcome.type === "aborted" || (signal == null ? void 0 : signal.aborted)) {
+        throw signal.reason instanceof Error ? signal.reason : new import_plugin_workflow.WorkflowTimeoutError();
+      }
+      return {
+        status: import_plugin_workflow.JOB_STATUS.ERROR,
+        result: error instanceof Error ? error.message : String(error)
+      };
+    }
+    if (outcome.type === "aborted") {
+      throw (signal == null ? void 0 : signal.reason) instanceof Error ? signal.reason : new import_plugin_workflow.WorkflowTimeoutError();
+    }
+    if (outcome.type === "error") {
+      return {
+        status: import_plugin_workflow.JOB_STATUS.ERROR,
+        result: outcome.error.message
+      };
+    }
+    if (outcome.type === "exit" && outcome.code !== 0) {
+      return {
+        status: import_plugin_workflow.JOB_STATUS.ERROR,
+        result: `Worker stopped with exit code ${outcome.code}`
+      };
+    }
+    return {
+      status: import_plugin_workflow.JOB_STATUS.RESOLVED,
+      result: outcome.type === "result" ? outcome.result : void 0
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScriptWorkerRunner
+});

package/dist/server/TaskConsumer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+import type WorkflowPlugin from '@nocobase/plugin-workflow';
+import type { QueueEventOptions } from '@nocobase/server';
+import { RunningJobs } from './RunningJobs';
+export declare class TaskConsumer {
+    private readonly workflowPlugin;
+    private readonly runningJobs;
+    private ready;
+    private closing;
+    private readonly processing;
+    constructor(workflowPlugin: WorkflowPlugin, runningJobs: RunningJobs);
+    setReady(ready: boolean): void;
+    idle(): boolean;
+    beforeStop(): Promise<void>;
+    readonly process: QueueEventOptions['process'];
+    private processWithPermit;
+    private claimJob;
+    private finishClaimedJob;
+    private settleClaimedJob;
+    private updatePendingJob;
+    private startClaimHeartbeat;
+}