@pauldeng/node-red-contrib-bullmq 1.0.0

package/examples/repeatable_jobs.json

@@ -0,0 +1,245 @@
+[
+  {
+    "id": "flow-repeatable-jobs",
+    "type": "tab",
+    "label": "BullMQ repeatable jobs",
+    "disabled": false,
+    "info": "Dedicated repeatable job command examples for BullMQ Job Scheduler compatibility commands."
+  },
+  {
+    "id": "queue-repeatable-jobs",
+    "type": "bull-queue-server",
+    "name": "basecasts",
+    "deployment": "single",
+    "address": "localhost",
+    "port": "6379",
+    "db": "",
+    "clusterNodes": "",
+    "sentinels": "",
+    "sentinelMasterName": "",
+    "username": "",
+    "sentinelUsername": "",
+    "tls": false,
+    "sentinelTls": false,
+    "tlsRejectUnauthorized": true,
+    "tlsServerName": "",
+    "prefix": ""
+  },
+  {
+    "id": "inject-repeat-add",
+    "type": "inject",
+    "z": "flow-repeatable-jobs",
+    "name": "repeat: add basecasts job",
+    "props": [{ "p": "payload" }],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "topic": "",
+    "payload": "gateway-FCC23DFFFE0AA2A8",
+    "payloadType": "str",
+    "x": 180,
+    "y": 100,
+    "wires": [["fn-repeat-add"]]
+  },
+  {
+    "id": "fn-repeat-add",
+    "type": "function",
+    "z": "flow-repeatable-jobs",
+    "name": "add repeat cron",
+    "func": "msg.cmd = \"add\";\nmsg.jobopts = {\"jobId\": msg.payload, \"repeat\": {\"cron\": \"30 9,19,29,39,49,59 * * * *\"}};\nreturn msg;",
+    "outputs": 1,
+    "noerr": 0,
+    "initialize": "",
+    "finalize": "",
+    "libs": [],
+    "x": 430,
+    "y": 100,
+    "wires": [["cmd-repeatable-jobs"]]
+  },
+  {
+    "id": "inject-repeat-get-all",
+    "type": "inject",
+    "z": "flow-repeatable-jobs",
+    "name": "repeat: getRepeatableJobs",
+    "props": [{ "p": "payload" }],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "topic": "",
+    "payload": "",
+    "payloadType": "str",
+    "x": 190,
+    "y": 180,
+    "wires": [["fn-repeat-get-all"]]
+  },
+  {
+    "id": "fn-repeat-get-all",
+    "type": "function",
+    "z": "flow-repeatable-jobs",
+    "name": "getRepeatableJobs",
+    "func": "msg.cmd = \"getRepeatableJobs\";\nreturn msg;",
+    "outputs": 1,
+    "noerr": 0,
+    "initialize": "",
+    "finalize": "",
+    "libs": [],
+    "x": 440,
+    "y": 180,
+    "wires": [["cmd-repeatable-jobs"]]
+  },
+  {
+    "id": "inject-repeat-count",
+    "type": "inject",
+    "z": "flow-repeatable-jobs",
+    "name": "repeat: count",
+    "props": [{ "p": "payload" }],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "topic": "",
+    "payload": "",
+    "payloadType": "str",
+    "x": 150,
+    "y": 260,
+    "wires": [["fn-repeat-count"]]
+  },
+  {
+    "id": "fn-repeat-count",
+    "type": "function",
+    "z": "flow-repeatable-jobs",
+    "name": "count",
+    "func": "msg.cmd = \"count\";\nreturn msg;",
+    "outputs": 1,
+    "noerr": 0,
+    "initialize": "",
+    "finalize": "",
+    "libs": [],
+    "x": 410,
+    "y": 260,
+    "wires": [["cmd-repeatable-jobs"]]
+  },
+  {
+    "id": "inject-repeat-get-by-key",
+    "type": "inject",
+    "z": "flow-repeatable-jobs",
+    "name": "repeat: getRepeatableJobByKey",
+    "props": [{ "p": "payload" }],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "topic": "",
+    "payload": "gateway-FCC23DFFFE0AA2A8",
+    "payloadType": "str",
+    "x": 220,
+    "y": 340,
+    "wires": [["fn-repeat-get-by-key"]]
+  },
+  {
+    "id": "fn-repeat-get-by-key",
+    "type": "function",
+    "z": "flow-repeatable-jobs",
+    "name": "getRepeatableJobByKey",
+    "func": "msg.cmd = \"getRepeatableJobByKey\";\nmsg.jobid = msg.payload;\nreturn msg;",
+    "outputs": 1,
+    "noerr": 0,
+    "initialize": "",
+    "finalize": "",
+    "libs": [],
+    "x": 470,
+    "y": 340,
+    "wires": [["cmd-repeatable-jobs"]]
+  },
+  {
+    "id": "inject-repeat-remove-by-key",
+    "type": "inject",
+    "z": "flow-repeatable-jobs",
+    "name": "repeat: removeRepeatableByKey",
+    "props": [{ "p": "payload" }],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "topic": "",
+    "payload": "gateway-FCC23DFFFE0AA2A8",
+    "payloadType": "str",
+    "x": 230,
+    "y": 420,
+    "wires": [["fn-repeat-remove-by-key"]]
+  },
+  {
+    "id": "fn-repeat-remove-by-key",
+    "type": "function",
+    "z": "flow-repeatable-jobs",
+    "name": "removeRepeatableByKey",
+    "func": "msg.cmd = \"removeRepeatableByKey\";\nmsg.jobid = msg.payload;\nreturn msg;",
+    "outputs": 1,
+    "noerr": 0,
+    "initialize": "",
+    "finalize": "",
+    "libs": [],
+    "x": 480,
+    "y": 420,
+    "wires": [["cmd-repeatable-jobs"]]
+  },
+  {
+    "id": "inject-repeat-stop-all",
+    "type": "inject",
+    "z": "flow-repeatable-jobs",
+    "name": "repeat: stopAndRemoveAllJobs",
+    "props": [{ "p": "payload" }],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "topic": "",
+    "payload": "",
+    "payloadType": "str",
+    "x": 210,
+    "y": 500,
+    "wires": [["fn-repeat-stop-all"]]
+  },
+  {
+    "id": "fn-repeat-stop-all",
+    "type": "function",
+    "z": "flow-repeatable-jobs",
+    "name": "stopAndRemoveAllJobs",
+    "func": "msg.cmd = \"stopAndRemoveAllJobs\";\nreturn msg;",
+    "outputs": 1,
+    "noerr": 0,
+    "initialize": "",
+    "finalize": "",
+    "libs": [],
+    "x": 470,
+    "y": 500,
+    "wires": [["cmd-repeatable-jobs"]]
+  },
+  {
+    "id": "cmd-repeatable-jobs",
+    "type": "bull cmd",
+    "z": "flow-repeatable-jobs",
+    "name": "run repeat command",
+    "queue": "queue-repeatable-jobs",
+    "x": 740,
+    "y": 260,
+    "wires": [["debug-repeatable-jobs"]]
+  },
+  {
+    "id": "debug-repeatable-jobs",
+    "type": "debug",
+    "z": "flow-repeatable-jobs",
+    "name": "repeat command output",
+    "active": true,
+    "tosidebar": true,
+    "console": false,
+    "tostatus": false,
+    "complete": "true",
+    "targetType": "full",
+    "x": 1000,
+    "y": 260,
+    "wires": []
+  }
+]

package/lib/acknowledgements.js

@@ -0,0 +1,110 @@
+"use strict";
+
+const { EventEmitter, once } = require("node:events");
+
+class AcknowledgementEntry {
+  constructor(context, timeoutMs) {
+    this.events = new EventEmitter();
+    this.settled = false;
+    this.job = context.job;
+    this.queue = context.queue;
+    this.queueName = context.queueName;
+    this.runNodeId = context.runNodeId;
+    this.timeout = undefined;
+
+    if (timeoutMs > 0) {
+      this.timeout = setTimeout(() => {
+        this.fail(
+          new Error(
+            `BullMQ job acknowledgement timed out after ${timeoutMs}ms`,
+          ),
+        );
+      }, timeoutMs);
+    }
+  }
+
+  async wait() {
+    const [settlement] = await once(this.events, "settled");
+    if (settlement.type === "reject") {
+      throw settlement.error;
+    }
+    return settlement.value;
+  }
+
+  complete(value) {
+    this.settle({ type: "resolve", value });
+  }
+
+  fail(error) {
+    this.settle({ type: "reject", error });
+  }
+
+  settle(settlement) {
+    if (this.settled) {
+      return;
+    }
+    this.settled = true;
+    clearTimeout(this.timeout);
+    this.events.emit("settled", settlement);
+  }
+}
+
+// Parse a manual-acknowledgement timeout. Empty, non-numeric, or negative
+// values fall back to defaultMs; 0 disables the timeout (wait indefinitely).
+function parseAckTimeoutMs(value, defaultMs = 300000) {
+  if (value === undefined || value === null || value === "") {
+    return defaultMs;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return defaultMs;
+  }
+  return parsed;
+}
+
+class AcknowledgementRegistry {
+  constructor() {
+    this.entries = new Map();
+  }
+
+  create(context, timeoutMs) {
+    const ackId = `${context.runNodeId}:${context.job.id}:${Date.now()}:${Math.random()
+      .toString(36)
+      .slice(2)}`;
+
+    const entry = new AcknowledgementEntry(context, timeoutMs);
+    this.entries.set(ackId, entry);
+    // Drop the entry as soon as it settles (complete, fail, timeout, or
+    // rejectByRunNode) so the registry never accumulates finished jobs.
+    entry.events.once("settled", () => {
+      this.entries.delete(ackId);
+    });
+    return { ackId, entry };
+  }
+
+  get(ackId) {
+    const entry = this.entries.get(ackId);
+    if (!entry) {
+      throw new Error(
+        "Missing, stale, or already-settled BullMQ acknowledgement",
+      );
+    }
+    return entry;
+  }
+
+  rejectByRunNode(runNodeId, err) {
+    // Snapshot first: failing an entry settles it, which removes it from the
+    // map via the "settled" handler registered in create().
+    for (const entry of Array.from(this.entries.values())) {
+      if (entry.runNodeId === runNodeId) {
+        entry.fail(err);
+      }
+    }
+  }
+}
+
+module.exports = {
+  AcknowledgementEntry,
+  AcknowledgementRegistry,
+  parseAckTimeoutMs,
+};

package/lib/commands.js

@@ -0,0 +1,230 @@
+"use strict";
+
+const {
+  getLegacySchedulerId,
+  normalizeAddRequest,
+  serializeScheduler,
+} = require("./scheduler");
+const { serializeJob } = require("./serialization");
+
+const CLEAN_STATES = ["completed", "failed", "delayed", "wait"];
+
+function valueOrDefault(value, defaultValue) {
+  return value === undefined || value === null ? defaultValue : value;
+}
+
+async function getRequiredJob(queue, msg) {
+  const jobId = String(msg.jobId || msg.jobid || "").trim();
+  if (!jobId) {
+    throw new Error("msg.jobId is required");
+  }
+  const job = await queue.getJob(jobId);
+  if (!job) {
+    throw new Error(`Job not found: ${jobId}`);
+  }
+  return job;
+}
+
+async function dispatchAdd(queue, msg) {
+  const request = normalizeAddRequest(msg);
+  if (request.kind === "scheduler") {
+    return serializeJob(
+      await queue.upsertJobScheduler(
+        request.schedulerId,
+        request.repeat,
+        request.template,
+      ),
+    );
+  }
+  return serializeJob(
+    await queue.add(request.name, request.data, request.opts),
+  );
+}
+
+async function dispatchStopAndRemoveAllJobs(queue) {
+  const schedulers = await queue.getJobSchedulers(0, -1, true);
+  const removedSchedulers = [];
+  for (const scheduler of schedulers || []) {
+    const id = scheduler.id || scheduler.key;
+    if (id) {
+      await queue.removeJobScheduler(id);
+      removedSchedulers.push(id);
+    }
+  }
+
+  await queue.drain(true);
+
+  const cleaned = {};
+  for (const state of CLEAN_STATES) {
+    cleaned[state] = await queue.clean(0, 1000, state);
+  }
+
+  return { removedSchedulers, cleaned };
+}
+
+async function dispatchCommand(queue, msg = {}) {
+  const cmd = msg.cmd || msg.command || "add";
+
+  switch (cmd) {
+    case "add":
+      return dispatchAdd(queue, msg);
+    case "addBulk":
+      return (await queue.addBulk(msg.payload || [])).map(serializeJob);
+    case "getJob":
+      return serializeJob(await queue.getJob(msg.jobId || msg.jobid));
+    case "getJobs":
+      return (
+        await queue.getJobs(
+          msg.types,
+          valueOrDefault(msg.start, 0),
+          valueOrDefault(msg.end, -1),
+          valueOrDefault(msg.asc, false),
+        )
+      ).map(serializeJob);
+    case "getJobState": {
+      const job = await getRequiredJob(queue, msg);
+      return job.getState();
+    }
+    case "removeJob": {
+      const job = await getRequiredJob(queue, msg);
+      await job.remove();
+      return true;
+    }
+    case "retryJob": {
+      const job = await getRequiredJob(queue, msg);
+      await job.retry(msg.state);
+      return serializeJob(job);
+    }
+    case "retryJobs":
+      return queue.retryJobs(msg.opts || {});
+    case "getDelayed":
+      return (
+        await queue.getDelayed(
+          valueOrDefault(msg.start, 0),
+          valueOrDefault(msg.end, -1),
+          valueOrDefault(msg.asc, false),
+        )
+      ).map(serializeJob);
+    case "changeDelay": {
+      const job = await getRequiredJob(queue, msg);
+      await job.changeDelay(msg.delay);
+      return serializeJob(job);
+    }
+    case "promoteJob": {
+      const job = await getRequiredJob(queue, msg);
+      await job.promote();
+      return serializeJob(job);
+    }
+    case "promoteJobs":
+      return queue.promoteJobs();
+    case "getPrioritized":
+      return (
+        await queue.getPrioritized(
+          valueOrDefault(msg.start, 0),
+          valueOrDefault(msg.end, -1),
+        )
+      ).map(serializeJob);
+    case "getCountsPerPriority":
+      return queue.getCountsPerPriority(msg.priorities || []);
+    case "changePriority": {
+      const job = await getRequiredJob(queue, msg);
+      await job.changePriority({
+        priority: msg.priority,
+        lifo: valueOrDefault(msg.lifo, false),
+      });
+      return serializeJob(job);
+    }
+    case "getDeduplicationJobId":
+      return queue.getDeduplicationJobId(msg.deduplicationId);
+    case "removeDeduplicationKey":
+      return queue.removeDeduplicationKey(msg.deduplicationId);
+    case "upsertJobScheduler":
+      return serializeJob(
+        await queue.upsertJobScheduler(
+          getLegacySchedulerId(msg),
+          msg.repeat,
+          msg.template,
+        ),
+      );
+    case "getJobScheduler":
+      return serializeScheduler(
+        await queue.getJobScheduler(getLegacySchedulerId(msg)),
+      );
+    case "getJobSchedulers":
+    case "getRepeatableJobs":
+      return (
+        await queue.getJobSchedulers(
+          valueOrDefault(msg.start, 0),
+          valueOrDefault(msg.end, -1),
+          valueOrDefault(msg.asc, true),
+        )
+      ).map(serializeScheduler);
+    case "getJobSchedulersCount":
+    case "count":
+      return queue.getJobSchedulersCount();
+    case "removeJobScheduler":
+    case "removeRepeatableByKey":
+      return queue.removeJobScheduler(getLegacySchedulerId(msg));
+    case "getRepeatableJobByKey":
+      return serializeScheduler(
+        await queue.getJobScheduler(getLegacySchedulerId(msg)),
+      );
+    case "getJobCounts":
+      return queue.getJobCounts(...(msg.types || []));
+    case "pause":
+      await queue.pause();
+      return true;
+    case "resume":
+      await queue.resume();
+      return true;
+    case "drain":
+      await queue.drain(valueOrDefault(msg.delayed, false));
+      return true;
+    case "clean":
+      return queue.clean(
+        valueOrDefault(msg.grace, 0),
+        valueOrDefault(msg.limit, 1000),
+        msg.state || "completed",
+      );
+    case "stopAndRemoveAllJobs":
+      return dispatchStopAndRemoveAllJobs(queue);
+    case "setGlobalConcurrency":
+      await queue.setGlobalConcurrency(msg.concurrency);
+      return true;
+    case "getGlobalConcurrency":
+      return queue.getGlobalConcurrency();
+    case "removeGlobalConcurrency":
+      return queue.removeGlobalConcurrency();
+    case "setGlobalRateLimit":
+      await queue.setGlobalRateLimit(msg.max, msg.duration);
+      return true;
+    case "getGlobalRateLimit":
+      return queue.getGlobalRateLimit();
+    case "removeGlobalRateLimit":
+      return queue.removeGlobalRateLimit();
+    case "rateLimit":
+      await queue.rateLimit(msg.duration);
+      return true;
+    case "getRateLimitTtl":
+      return queue.getRateLimitTtl(msg.maxJobs);
+    case "removeRateLimitKey":
+      return queue.removeRateLimitKey();
+    case "addJobLog":
+      return queue.addJobLog(msg.jobId || msg.jobid, msg.logRow, msg.keepLogs);
+    case "getJobLogs":
+      return queue.getJobLogs(
+        msg.jobId || msg.jobid,
+        valueOrDefault(msg.start, 0),
+        valueOrDefault(msg.end, -1),
+        valueOrDefault(msg.asc, true),
+      );
+    case "exportPrometheusMetrics":
+      return queue.exportPrometheusMetrics();
+    default:
+      throw new Error(`Unsupported bull cmd: ${cmd}`);
+  }
+}
+
+module.exports = {
+  dispatchCommand,
+};