bullmq 5.77.2 → 5.77.3

package/dist/cjs/classes/bun-redis-client.js

@@ -85,9 +85,6 @@ class BunRedisAdapter extends events_1.EventEmitter {
         this.hasConnected = false;
         this.closed = false;
         this.closing = false;
-        // Serialize raw send() calls per connection to avoid Bun delivering
-        // concurrent command responses to the wrong pending promise.
-        this.sendQueue = Promise.resolve();
         // Auto-reconnect state
         this.reconnecting = false;
         this.reconnectTimer = null;
@@ -404,31 +401,24 @@ class BunRedisAdapter extends events_1.EventEmitter {
         }));
     }
     sendCommand(command, args) {
-        // If the connection is already closing/closed, return a rejected promise
-        // directly without going through sendQueue.
+        // If the connection is already closing/closed, return a rejected promise.
         if (this.closing || this.closed) {
             return Promise.reject(new connection_closed_error_1.ConnectionClosedError('Connection is closed'));
         }
-        const run = this.sendQueue.then(() => {
-            if (this.closing || this.closed) {
-                return Promise.reject(new connection_closed_error_1.ConnectionClosedError('Connection is closed'));
+        // Send directly to the underlying Bun client. Redis protocol guarantees
+        // responses arrive in the same order as requests on a single connection,
+        // so concurrent send() calls are safe and enable implicit pipelining
+        // (multiple commands written to the socket before any response is read).
+        // MULTI/EXEC transactions don't go through this path — they are issued
+        // as a synchronous burst of raw `send()` calls in
+        // `BunRedisTransaction.exec()`, which guarantees the MULTI…EXEC frames
+        // are written contiguously without any other command interleaving.
+        return this.raw.send(command, args).catch((err) => {
+            if (isBunConnectionClosedError(err)) {
+                return Promise.reject(new connection_closed_error_1.ConnectionClosedError(this.closing || this.closed ? 'Connection is closed' : err.message, err));
             }
-            return this.raw.send(command, args).catch((err) => {
-                if (isBunConnectionClosedError(err)) {
-                    return Promise.reject(new connection_closed_error_1.ConnectionClosedError(this.closing || this.closed
-                        ? 'Connection is closed'
-                        : err.message, err));
-                }
-                throw err;
-            });
+            throw err;
         });
-        this.sendQueue = run.then(() => undefined, () => undefined);
-        return run;
-    }
-    async queueExclusive(operation) {
-        const run = this.sendQueue.then(operation, operation);
-        this.sendQueue = run.then(() => undefined, () => undefined);
-        return run;
     }
     // ---------------------------------------------------------------
     // Pipeline / Transaction
@@ -973,41 +963,54 @@ class BunRedisTransaction {
                 return [null, value];
             });
         }
-        // Execute as one exclusive queued operation so no command can be interleaved
-        // between MULTI and EXEC on this connection.
-        return this.adapter.queueExclusive(async () => {
-            try {
-                await this.raw.send('MULTI', []);
-                // Queue all MULTI commands in the same turn without awaiting each send.
-                // This avoids yielding between command enqueues before EXEC is issued.
-                const queuedCommandPromises = this.commands.map(({ cmd, args }) => this.raw.send(cmd, args));
-                // Issue EXEC immediately after enqueuing queued commands.
-                const results = await this.raw.send('EXEC', []);
-                // Prevent unhandled rejections from queued command promises.
-                await Promise.allSettled(queuedCommandPromises);
-                if (!results) {
-                    return null;
-                }
-                // Normalize to ioredis format: [Error | null, value][]
-                return results.map((result, i) => {
-                    if (result instanceof Error) {
-                        return [result, null];
-                    }
-                    const transformer = this.transformers[i];
-                    const value = transformer ? transformer(result) : result;
-                    return [null, value];
-                });
+        // Execute as a pipelined MULTI/EXEC block. Redis supports multiple
+        // MULTI/EXEC blocks pipelined on the same connection — each MULTI starts
+        // a new transaction context and EXEC commits it, responses arrive in
+        // order. We fire MULTI + all commands + EXEC synchronously (no await
+        // between them) so they're written to the socket buffer as one contiguous
+        // burst with no opportunity for interleaving from other async contexts.
+        //
+        // The MULTI and per-command `send()` calls are intentionally fire-and-
+        // forget for performance, but their returned promises must still have a
+        // rejection handler attached to avoid Bun emitting "unhandled promise
+        // rejection" warnings if the connection drops or Redis returns an error
+        // reply before we reach EXEC. The actual failure is reported through the
+        // awaited EXEC promise (which Redis rejects in the same situations), or
+        // bubbles up via the surrounding `try/catch`.
+        const swallow = (_) => {
+            /* error surfaces via EXEC or the outer try/catch */
+        };
+        try {
+            // Fire MULTI without awaiting — no round-trip needed before commands.
+            this.raw.send('MULTI', []).catch(swallow);
+            // Fire all queued commands synchronously (no awaits).
+            for (const { cmd, args } of this.commands) {
+                this.raw.send(cmd, args).catch(swallow);
             }
-            catch (err) {
-                // Try to discard the MULTI state on error
-                try {
-                    await this.raw.send('DISCARD', []);
-                }
-                catch (_a) {
-                    // ignore
+            // EXEC is the only await — it returns the array of results.
+            const results = await this.raw.send('EXEC', []);
+            if (!results) {
+                return null;
+            }
+            // Normalize to ioredis format: [Error | null, value][]
+            return results.map((result, i) => {
+                if (result instanceof Error) {
+                    return [result, null];
                 }
-                throw err;
+                const transformer = this.transformers[i];
+                const value = transformer ? transformer(result) : result;
+                return [null, value];
+            });
+        }
+        catch (err) {
+            // Try to discard the MULTI state on error
+            try {
+                await this.raw.send('DISCARD', []);
             }
-        });
+            catch (_a) {
+                // ignore
+            }
+            throw err;
+        }
     }
 }