@nocobase/plugin-workflow-javascript 2.1.36 → 2.1.38

package/dist/server/ScriptInstruction.js

@@ -39,102 +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");
-function isWorkerResult(message) {
-  return typeof message === "object" && message !== null && "type" in message && message.type === "result";
-}
+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;
-    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 (e) {
-      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: e instanceof Error ? e.message : String(e)
-      };
-    }
-    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
-    };
+    return import_ScriptWorkerRunner.ScriptWorkerRunner.run(source, args, options);
   }
   configSchema = import_joi.default.object({
     content: import_joi.default.string(),
@@ -148,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 }), {});
@@ -170,60 +92,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...`);
-    const abortHandle = processor.createBackgroundAbortHandle();
+    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)
+      });
+    };
+    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 processor.exit();
+      await this.workflow.app.eventQueue.publish(import_constants.PENDING_JAVASCRIPT_TASK_CHANNEL, {
+        jobId: id
+      });
     } catch (error) {
-      abortHandle.dispose();
-      throw error;
+      processor.logger.error(`publishing JavaScript job (${id}) failed, recovery will republish it`, { error });
     }
-    const jobResult = {
-      status: import_plugin_workflow.JOB_STATUS.PENDING
-    };
-    this.constructor.run(content, _args, { timeout, logger: processor.logger, signal: abortHandle.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(() => {
-      abortHandle.dispose();
-      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);
-        await this.workflow.resume(job).catch(() => {
-        });
-      });
-    });
   }
   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;
+}