@pauldeng/node-red-contrib-bullmq 1.0.0

package/lib/connections.js

@@ -0,0 +1,300 @@
+"use strict";
+
+const DEFAULT_REDIS_HOST = "localhost";
+const DEFAULT_REDIS_PORT = 6379;
+const CLUSTER_PREFIX = "{bull}";
+
+function isPresent(value) {
+  return value !== undefined && value !== null && value !== "";
+}
+
+function toBoolean(value, defaultValue = false) {
+  if (value === undefined || value === null || value === "") {
+    return defaultValue;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  return ["true", "1", "yes", "on"].includes(String(value).toLowerCase());
+}
+
+function toPort(value, defaultValue = DEFAULT_REDIS_PORT) {
+  if (!isPresent(value)) {
+    return defaultValue;
+  }
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid Redis port: ${value}`);
+  }
+  return port;
+}
+
+function parseEndpoint(endpoint, defaultPort = DEFAULT_REDIS_PORT) {
+  if (typeof endpoint === "object" && endpoint !== null) {
+    const host = endpoint.host || endpoint.address;
+    if (!isPresent(host)) {
+      throw new Error("Redis endpoint requires a host");
+    }
+    return {
+      host: String(host).trim(),
+      port: toPort(endpoint.port, defaultPort),
+    };
+  }
+
+  const text = String(endpoint || "").trim();
+  if (!text) {
+    throw new Error("Redis endpoint cannot be empty");
+  }
+
+  let host = text;
+  let port = defaultPort;
+  const urlMatch = text.match(
+    /^(?:redis|rediss):\/\/(?:[^@]+@)?([^/:]+)(?::(\d+))?/i,
+  );
+  if (urlMatch) {
+    host = urlMatch[1];
+    port = toPort(urlMatch[2], defaultPort);
+  } else if (text.includes(":")) {
+    const parts = text.split(":");
+    port = toPort(parts.pop(), defaultPort);
+    host = parts.join(":");
+  }
+
+  if (!host.trim()) {
+    throw new Error(`Redis endpoint requires a host: ${text}`);
+  }
+
+  return { host: host.trim(), port };
+}
+
+function parseEndpointList(value, defaultPort = DEFAULT_REDIS_PORT) {
+  if (Array.isArray(value)) {
+    return value
+      .flatMap((item) =>
+        typeof item === "string" ? item.split(/[\n,]+/) : [item],
+      )
+      .filter((item) => isPresent(item))
+      .map((item) => parseEndpoint(item, defaultPort));
+  }
+
+  if (!isPresent(value)) {
+    return [];
+  }
+
+  return String(value)
+    .split(/[\n,]+/)
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .map((item) => parseEndpoint(item, defaultPort));
+}
+
+function readSecret(config, credentials, name) {
+  if (credentials && isPresent(credentials[name])) {
+    return credentials[name];
+  }
+  return config[name];
+}
+
+function normalizeQueueConfig(config = {}, credentials = {}) {
+  const deploymentInput = String(
+    config.deployment || config.mode || config.redisMode || "single",
+  ).toLowerCase();
+  const deployment =
+    deploymentInput === "memorydb" ? "cluster" : deploymentInput;
+
+  if (!["single", "cluster", "sentinel"].includes(deployment)) {
+    throw new Error(`Unsupported Redis deployment mode: ${deploymentInput}`);
+  }
+
+  const host = config.host || config.address || DEFAULT_REDIS_HOST;
+  const port = toPort(config.port, DEFAULT_REDIS_PORT);
+  const queueName = String(config.queueName || config.name || "").trim();
+  if (!queueName) {
+    throw new Error("BullMQ queue name is required");
+  }
+
+  const normalized = {
+    queueName,
+    deployment,
+    host: String(host).trim(),
+    port,
+    db: isPresent(config.db) ? Number(config.db) : undefined,
+    username: config.username || undefined,
+    password: readSecret(config, credentials, "password") || undefined,
+    tls: toBoolean(config.tls, false),
+    tlsRejectUnauthorized: toBoolean(config.tlsRejectUnauthorized, true),
+    tlsCa: readSecret(config, credentials, "tlsCa") || undefined,
+    tlsCert: readSecret(config, credentials, "tlsCert") || undefined,
+    tlsKey: readSecret(config, credentials, "tlsKey") || undefined,
+    tlsServerName: config.tlsServerName || undefined,
+    prefix: config.prefix || undefined,
+    clusterNodes: parseEndpointList(config.clusterNodes || config.startupNodes),
+    sentinelMasterName:
+      config.sentinelMasterName || config.masterName || config.nameOfMaster,
+    sentinels: parseEndpointList(config.sentinels, 26379),
+    sentinelUsername: config.sentinelUsername || undefined,
+    sentinelPassword:
+      readSecret(config, credentials, "sentinelPassword") || undefined,
+    sentinelTls: toBoolean(config.sentinelTls, false),
+  };
+
+  if (deployment === "cluster") {
+    if (normalized.clusterNodes.length === 0) {
+      normalized.clusterNodes = [
+        { host: normalized.host, port: normalized.port },
+      ];
+    }
+    normalized.prefix = normalized.prefix || CLUSTER_PREFIX;
+  }
+
+  if (deployment === "sentinel") {
+    if (!normalized.sentinelMasterName) {
+      throw new Error("Sentinel deployment requires a master name");
+    }
+    if (normalized.sentinels.length === 0) {
+      normalized.sentinels = [{ host: normalized.host, port: 26379 }];
+    }
+  }
+
+  return normalized;
+}
+
+function buildTlsOptions(config, enabled) {
+  if (!enabled) {
+    return undefined;
+  }
+
+  const tls = {
+    rejectUnauthorized: config.tlsRejectUnauthorized,
+  };
+
+  if (config.tlsServerName) {
+    tls.servername = config.tlsServerName;
+  }
+  if (config.tlsCa) {
+    tls.ca = config.tlsCa;
+  }
+  if (config.tlsCert) {
+    tls.cert = config.tlsCert;
+  }
+  if (config.tlsKey) {
+    tls.key = config.tlsKey;
+  }
+
+  return tls;
+}
+
+function retryValueForRole(role) {
+  return role === "worker" || role === "events" ? null : 1;
+}
+
+function buildStandaloneOptions(config, role) {
+  const options = {
+    host: config.host,
+    port: config.port,
+    maxRetriesPerRequest: retryValueForRole(role),
+    enableReadyCheck: true,
+    connectTimeout: 10000,
+  };
+
+  if (config.db !== undefined && !Number.isNaN(config.db)) {
+    options.db = config.db;
+  }
+  if (config.username) {
+    options.username = config.username;
+  }
+  if (config.password) {
+    options.password = config.password;
+  }
+  const tls = buildTlsOptions(config, config.tls);
+  if (tls) {
+    options.tls = tls;
+  }
+
+  return options;
+}
+
+function buildRedisDescriptor(config, role = "producer") {
+  if (config.deployment === "cluster") {
+    const redisOptions = {
+      maxRetriesPerRequest: retryValueForRole(role),
+      enableReadyCheck: true,
+      connectTimeout: 10000,
+    };
+    if (config.username) {
+      redisOptions.username = config.username;
+    }
+    if (config.password) {
+      redisOptions.password = config.password;
+    }
+    const tls = buildTlsOptions(config, config.tls);
+    if (tls) {
+      redisOptions.tls = tls;
+    }
+
+    return {
+      kind: "cluster",
+      startupNodes: config.clusterNodes,
+      options: {
+        redisOptions,
+        slotsRefreshTimeout: 2000,
+        maxRedirections: 16,
+        dnsLookup: (address, callback) => callback(null, address),
+      },
+    };
+  }
+
+  if (config.deployment === "sentinel") {
+    const options = buildStandaloneOptions(config, role);
+    delete options.host;
+    delete options.port;
+    if (config.db !== undefined && !Number.isNaN(config.db)) {
+      options.db = config.db;
+    }
+    options.sentinels = config.sentinels;
+    options.name = config.sentinelMasterName;
+    if (config.sentinelUsername) {
+      options.sentinelUsername = config.sentinelUsername;
+    }
+    if (config.sentinelPassword) {
+      options.sentinelPassword = config.sentinelPassword;
+    }
+    if (config.sentinelTls) {
+      options.enableTLSForSentinelMode = true;
+      options.sentinelTLS = buildTlsOptions(config, true);
+    }
+
+    return { kind: "single", options };
+  }
+
+  return { kind: "single", options: buildStandaloneOptions(config, role) };
+}
+
+function createRedisConnection(descriptor, IORedis) {
+  if (descriptor.kind === "cluster") {
+    return new IORedis.Cluster(descriptor.startupNodes, descriptor.options);
+  }
+  return new IORedis(descriptor.options);
+}
+
+function buildBullMQOptions(config, connection) {
+  const options = {};
+  if (connection) {
+    options.connection = connection;
+  }
+  if (config.prefix) {
+    options.prefix = config.prefix;
+  }
+  return options;
+}
+
+module.exports = {
+  buildBullMQOptions,
+  buildRedisDescriptor,
+  createRedisConnection,
+  normalizeQueueConfig,
+  parseEndpointList,
+};

package/lib/scheduler.js

@@ -0,0 +1,114 @@
+"use strict";
+
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+function clonePlain(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  return { ...value };
+}
+
+function normalizeRepeatOptions(repeat) {
+  const normalized = clonePlain(repeat) || {};
+  if (
+    normalized.cron &&
+    normalized.pattern &&
+    normalized.cron !== normalized.pattern
+  ) {
+    throw new Error(
+      "repeat.cron and repeat.pattern must match when both are supplied",
+    );
+  }
+  if (normalized.cron) {
+    normalized.pattern = normalized.cron;
+    delete normalized.cron;
+  }
+  return normalized;
+}
+
+function getJobData(msg) {
+  if (hasOwn(msg, "jobData")) {
+    return msg.jobData;
+  }
+  return { payload: msg.payload };
+}
+
+function normalizeAddRequest(msg = {}) {
+  const jobopts = clonePlain(msg.jobopts) || {};
+  const name = msg.jobName || "default";
+
+  if (jobopts.repeat) {
+    const schedulerId = String(msg.schedulerId || jobopts.jobId || "").trim();
+    if (!schedulerId) {
+      throw new Error(
+        "scheduled jobs require msg.schedulerId or msg.jobopts.jobId",
+      );
+    }
+
+    const repeat = normalizeRepeatOptions(jobopts.repeat);
+    delete jobopts.repeat;
+    delete jobopts.jobId;
+
+    return {
+      kind: "scheduler",
+      schedulerId,
+      repeat,
+      template: {
+        name,
+        data: getJobData(msg),
+        opts: jobopts,
+      },
+    };
+  }
+
+  return {
+    kind: "job",
+    name,
+    data: getJobData(msg),
+    opts: jobopts,
+  };
+}
+
+function getLegacySchedulerId(msg = {}) {
+  const schedulerId = String(
+    msg.schedulerId || msg.jobid || msg.jobId || "",
+  ).trim();
+  if (!schedulerId) {
+    throw new Error("A scheduler id is required");
+  }
+  return schedulerId;
+}
+
+function serializeScheduler(scheduler) {
+  if (!scheduler) {
+    return scheduler;
+  }
+
+  const result = {};
+  for (const key of [
+    "id",
+    "key",
+    "name",
+    "next",
+    "pattern",
+    "every",
+    "limit",
+    "offset",
+    "tz",
+    "endDate",
+  ]) {
+    if (hasOwn(scheduler, key)) {
+      result[key] = scheduler[key];
+    }
+  }
+  return result;
+}
+
+module.exports = {
+  getLegacySchedulerId,
+  normalizeAddRequest,
+  serializeScheduler,
+};

package/lib/serialization.js

@@ -0,0 +1,63 @@
+"use strict";
+
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+function copyKnownFields(source, fields) {
+  if (!source) {
+    return source;
+  }
+  const result = {};
+  for (const field of fields) {
+    const value = source[field];
+    if (value !== undefined) {
+      result[field] = value;
+    }
+  }
+  return result;
+}
+
+function serializeJob(job) {
+  if (!job) {
+    return job;
+  }
+
+  return copyKnownFields(job, [
+    "id",
+    "name",
+    "queueName",
+    "data",
+    "opts",
+    "progress",
+    "attemptsMade",
+    "failedReason",
+    "stacktrace",
+    "returnvalue",
+    "timestamp",
+    "processedOn",
+    "finishedOn",
+    "delay",
+    "priority",
+    "parentKey",
+    "deduplicationId",
+  ]);
+}
+
+function serializeFlowJob(flowJob) {
+  if (!flowJob) {
+    return flowJob;
+  }
+
+  return {
+    job: serializeJob(flowJob.job),
+    children: Array.isArray(flowJob.children)
+      ? flowJob.children.map(serializeFlowJob)
+      : undefined,
+  };
+}
+
+module.exports = {
+  serializeFlowJob,
+  serializeJob,
+};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@pauldeng/node-red-contrib-bullmq",
+  "version": "1.0.0",
+  "description": "BullMQ-backed Redis job queue nodes for Node-RED",
+  "main": "bull-queue.js",
+  "files": [
+    "bull-queue.js",
+    "bull-queue.html",
+    "lib/",
+    "icons/",
+    "examples/",
+    "docs/*.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "test:unit": "node --test test/*.test.js",
+    "test:integration": "BULLMQ_INTEGRATION=1 node --test test/integration-standalone.test.js",
+    "test:deployments": "node scripts/run-deployment-tests.js",
+    "test:playwright": "playwright test",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "validate": "npx --yes node-red-dev validate"
+  },
+  "dependencies": {
+    "bullmq": "5.78.0",
+    "ioredis": "5.10.1"
+  },
+  "license": "MIT",
+  "keywords": [
+    "node-red",
+    "bullmq",
+    "job",
+    "queue",
+    "bull",
+    "redis",
+    "worker",
+    "jobs"
+  ],
+  "node-red": {
+    "version": ">=4.1.0 <5",
+    "nodes": {
+      "bull-queue": "bull-queue.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pauldeng/node-red-contrib-bullmq.git"
+  },
+  "homepage": "https://github.com/pauldeng/node-red-contrib-bullmq#readme",
+  "bugs": {
+    "url": "https://github.com/pauldeng/node-red-contrib-bullmq/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "author": {
+    "name": "Paul Deng",
+    "email": "dengpeng.cn@gmail.com"
+  },
+  "devDependencies": {
+    "@playwright/test": "1.60.0",
+    "node-red": "4.1.11",
+    "node-red-node-test-helper": "^0.3.6",
+    "prettier": "3.8.3"
+  }
+}