bullmq 6.0.8 → 6.0.10

package/README.md

@@ -4,7 +4,7 @@
   <br/>
   <br/>
   <p>
-    The fastest, most reliable, Redis-based distributed queue for Node.js, Python, Elixir, Rust, PHP, and more. <br/>
+    The fastest, most reliable, Redis-based distributed queue for Node.js, Python, Elixir, .NET, Rust, PHP, and more. <br/>
     Carefully written for rock solid stability and atomicity.
   </p>
   Read the <a href="https://docs.bullmq.io">documentation</a>
@@ -46,6 +46,7 @@ BullMQ is available natively in multiple languages:
 - **Python** — [`python/`](./python) directory (`pip install bullmq`)
 - **Rust** — [`rust/`](./rust) directory (`cargo add bullmq-official --rename bullmq`)
 - **Elixir** — [`elixir/`](./elixir) directory (`{:bullmq, "~> x.x"}`)
+- **.Net** — [`dotnet/`](./dotnet) directory (`dotnet add package BullMQ`)
 - **PHP** — [`php/`](./php) directory
 
 For other platforms, check out the [BullMQ Proxy](https://github.com/taskforcesh/bullmq-proxy).

package/dist/cjs/classes/ioredis-client.js

@@ -8,26 +8,6 @@ exports.isIRedisClient = isIRedisClient;
  * event-listener identity for the BullMQ-facing client.
  */
 const proxyCache = new WeakMap();
-/**
- * Wraps an ioredis `Redis` / `Cluster` instance with a `Proxy` so it conforms
- * to {@link IRedisClient}.
- *
- * For backwards compatibility BullMQ continues to accept a raw `IORedis`
- * instance through tehe `connection` option, even though internally it relies
- * on the `IRedisClient` adapter interface. The returned proxy:
- *
- *   - exposes `runCommand` (Lua script dispatch by name)
- *   - exposes structured-options variants of `hset`, `set`, `zrange`,
- *     `zrevrange`, `xadd`, `xread`, `xtrim`, `scan` (backward-compatible:
- *     they still accept native ioredis varargs if called that way)
- *   - returns augmented {@link IRedisTransaction}s from `pipeline()` / `multi()`
- *   - wraps the result of `duplicate()` in a new proxy
- *
- * The underlying ioredis instance is **not** mutated. Properties and methods
- * not in the override table are forwarded to the raw client via the proxy
- * traps, with `this === target` so EventEmitter / Commander internals work
- * normally.
- */
 function createIORedisClient(client) {
     // If the caller already passed a proxy produced by this function, return
     // it as-is. Wrapping a proxy in a second proxy would defeat the WeakMap

package/dist/cjs/classes/redis-connection.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisConnection = void 0;
 const tslib_1 = require("tslib");
 const events_1 = require("events");
-const ioredis_1 = require("ioredis");
 const utils_1 = require("../utils");
 const version_1 = require("../version");
 const scripts = require("../scripts");
 const ioredis_client_1 = require("./ioredis-client");
+const node_redis_client_1 = require("./node-redis-client");
+const bun_redis_client_1 = require("./bun-redis-client");
 const connection_closed_error_1 = require("./errors/connection-closed-error");
 const overrideMessage = [
     'BullMQ: WARNING! Your redis options maxRetriesPerRequest must be null',
@@ -27,6 +28,75 @@ const clusterClosingRefCount = Symbol('bullmqClusterClosingRefCount');
 // the worker. 30s is comfortably above the default ioredis slotsRefreshTimeout
 // while bounded enough that wedged workers recover within one or two ticks.
 const DEFAULT_CLUSTER_RECONNECT_TIMEOUT_MS = 30000;
+/**
+ * Lazily loads the optional `ioredis` driver. Users on another Redis driver
+ * (node-redis, Bun built-in, …) or on the PostgreSQL backend never hit this
+ * path, so they never need `ioredis` installed.
+ *
+ * Only reached when no {@link RedisConnection.clientFactory} is set and the
+ * caller did not pass an already-constructed client instance. In native ESM
+ * environments where `require` is unavailable, callers should provide a client
+ * instance or a `clientFactory` instead.
+ */
+function loadIORedis() {
+    var _a;
+    try {
+        if (typeof require === 'function') {
+            const mod = require('ioredis');
+            // ioredis exports the constructor both as the module itself (CJS) and
+            // under `default` (ESM interop); normalise to the constructor.
+            return (_a = mod.default) !== null && _a !== void 0 ? _a : mod;
+        }
+    }
+    catch (_b) {
+        // Fall through to the friendly error below.
+    }
+    throw new Error("BullMQ could not load the optional 'ioredis' package. " +
+        'Install it with `npm install ioredis`, or provide a different Redis ' +
+        'client instance (e.g. node-redis) via the connection option. In a ' +
+        'native ESM environment, pass an already-constructed client instance ' +
+        'instead of connection options.');
+}
+/**
+ * Wraps a raw client instance passed through the `connection` option in the
+ * matching {@link IRedisClient} adapter, auto-detecting the underlying driver.
+ *
+ * This lets consumers pass a native node-redis or Bun client directly (without
+ * manually calling `createNodeRedisClient` / `createBunRedisClient` or setting a
+ * global {@link RedisConnection.clientFactory}), so those users never need
+ * `ioredis` installed. ioredis instances keep their existing code path, so the
+ * behaviour is fully backwards compatible.
+ *
+ * Detection is purely structural (no driver package is imported), keying off
+ * markers that are unique to each client:
+ *   - ioredis exposes `defineCommand` (used to register Lua scripts);
+ *     node-redis and Bun do not.
+ *   - node-redis (`@redis/client`) exposes `sendCommand` plus `isOpen`/`isReady`.
+ *   - Bun's built-in `RedisClient` exposes `send` plus a `connected` flag.
+ */
+function wrapRedisInstance(instance) {
+    // Already an adapted IRedisClient (ioredis proxy, node-redis, Bun, or a
+    // custom implementation) — use as-is.
+    if ((0, ioredis_client_1.isIRedisClient)(instance)) {
+        return instance;
+    }
+    const hasDefineCommand = typeof instance.defineCommand === 'function';
+    // node-redis (@redis/client): `sendCommand` + `isOpen`/`isReady`, and no
+    // ioredis-style `defineCommand`.
+    if (!hasDefineCommand &&
+        typeof instance.sendCommand === 'function' &&
+        ('isOpen' in instance || 'isReady' in instance)) {
+        return (0, node_redis_client_1.createNodeRedisClient)(instance);
+    }
+    // Bun's built-in RedisClient: `send` + `connected`, and no `defineCommand`.
+    if (!hasDefineCommand &&
+        typeof instance.send === 'function' &&
+        'connected' in instance) {
+        return (0, bun_redis_client_1.createBunRedisClient)(instance);
+    }
+    // Default: treat as an ioredis instance (backwards compatible).
+    return (0, ioredis_client_1.createIORedisClient)(instance);
+}
 class RedisConnection extends events_1.EventEmitter {
     constructor(opts, extraOptions) {
         super();
@@ -51,10 +121,10 @@ class RedisConnection extends events_1.EventEmitter {
             }
         }
         else {
-            // Wrap raw ioredis instances in the IRedisClient adapter if not already wrapped
-            this._client = (0, ioredis_client_1.isIRedisClient)(opts)
-                ? opts
-                : (0, ioredis_client_1.createIORedisClient)(opts);
+            // Wrap raw client instances in the matching IRedisClient adapter,
+            // auto-detecting the driver (ioredis / node-redis / Bun) so callers can
+            // pass a native client directly without setting a clientFactory.
+            this._client = wrapRedisInstance(opts);
             // Test if the redis instance is using keyPrefix
             // and if so, throw an error.
             if (this._client.options.keyPrefix) {
@@ -187,7 +257,10 @@ class RedisConnection extends events_1.EventEmitter {
             }
             else {
                 const _a = this.opts, { url } = _a, rest = tslib_1.__rest(_a, ["url"]);
-                const ioredisClient = url ? new ioredis_1.default(url, rest) : new ioredis_1.default(rest);
+                const IORedisCtor = loadIORedis();
+                const ioredisClient = url
+                    ? new IORedisCtor(url, rest)
+                    : new IORedisCtor(rest);
                 this._client = (0, ioredis_client_1.createIORedisClient)(ioredisClient);
             }
         }