@zdavison/matador 4.0.1 → 4.0.2

package/dist/index.cjs

@@ -808,12 +808,22 @@ var FanoutEngine = class {
   topology;
   defaultQueue;
   enqueuingCount = 0;
+  retryBuffer = [];
+  maxRetryBufferSize;
+  disposeOnConnected;
   constructor(config) {
     this.transport = config.transport;
     this.schema = config.schema;
     this.hooks = config.hooks;
     this.topology = config.topology;
     this.defaultQueue = config.defaultQueue;
+    this.maxRetryBufferSize = config.maxRetryBufferSize ?? 5e3;
+    this.disposeOnConnected = this.transport.onConnected?.(() => {
+      void this.flushRetryBuffer();
+    });
+  }
+  dispose() {
+    this.disposeOnConnected?.();
   }
   /**
    * Current count of events being enqueued.
@@ -851,12 +861,13 @@ var FanoutEngine = class {
         universalMetadata,
         delayMs: options.delayMs
       });
+      const sendOptions = options.delayMs !== void 0 ? { delay: options.delayMs } : void 0;
       this.enqueuingCount++;
       try {
         const usedTransport = await this.transport.send(
           qualifiedQueue,
           envelope,
-          options.delayMs !== void 0 ? { delay: options.delayMs } : void 0
+          sendOptions
         );
         sent++;
         await this.hooks.onEnqueueSuccess({
@@ -866,17 +877,48 @@ var FanoutEngine = class {
         });
       } catch (error) {
         const cause = error instanceof Error ? error : new Error(String(error));
-        const err = new TransportSendError(qualifiedQueue, cause);
-        errors.push({
-          subscriberName: subscriber.name,
-          queue: qualifiedQueue,
-          error: err
-        });
-        await this.hooks.onEnqueueError({
-          envelope,
-          error: err,
-          transport: this.transport.name
-        });
+        const shouldBuffer = options.buffer !== false;
+        if (shouldBuffer && this.retryBuffer.length < this.maxRetryBufferSize) {
+          this.retryBuffer.push({
+            queue: qualifiedQueue,
+            envelope,
+            sendOptions,
+            subscriberName: subscriber.name
+          });
+          this.hooks.logger.warn(
+            `[Matador] \u{1F7E1} Message for '${subscriber.name}' buffered for retry on reconnect (buffer: ${this.retryBuffer.length}/${this.maxRetryBufferSize}).`
+          );
+          if (options.throwOnBufferedFailure) {
+            const err = new TransportSendError(qualifiedQueue, cause);
+            errors.push({
+              subscriberName: subscriber.name,
+              queue: qualifiedQueue,
+              error: err
+            });
+            await this.hooks.onEnqueueError({
+              envelope,
+              error: err,
+              transport: this.transport.name
+            });
+          }
+        } else {
+          if (shouldBuffer) {
+            this.hooks.logger.error(
+              `[Matador] \u{1F534} Retry buffer full (${this.maxRetryBufferSize}). Message for '${subscriber.name}' dropped and will not be retried.`
+            );
+          }
+          const err = new TransportSendError(qualifiedQueue, cause);
+          errors.push({
+            subscriberName: subscriber.name,
+            queue: qualifiedQueue,
+            error: err
+          });
+          await this.hooks.onEnqueueError({
+            envelope,
+            error: err,
+            transport: this.transport.name
+          });
+        }
       } finally {
         this.enqueuingCount--;
       }
@@ -888,6 +930,57 @@ var FanoutEngine = class {
       errors
     };
   }
+  /**
+   * Flushes the retry buffer
+   *
+   * This is called when the transport reconnects, and is used to retry any messages that were buffered while the transport was disconnected
+   */
+  async flushRetryBuffer() {
+    if (this.retryBuffer.length === 0) return;
+    this.hooks.logger.info(
+      `[Matador] \u23F3 Flushing ${this.retryBuffer.length} buffered message(s)...`
+    );
+    const toFlush = this.retryBuffer.splice(0);
+    for (const item of toFlush) {
+      this.enqueuingCount++;
+      try {
+        const usedTransport = await this.transport.send(
+          item.queue,
+          item.envelope,
+          item.sendOptions
+        );
+        await this.hooks.onEnqueueSuccess({
+          envelope: item.envelope,
+          queue: item.queue,
+          transport: usedTransport
+        });
+      } catch (error) {
+        if (this.retryBuffer.length < this.maxRetryBufferSize) {
+          this.retryBuffer.push(item);
+        } else {
+          const cause = error instanceof Error ? error : new Error(String(error));
+          const err = new TransportSendError(item.queue, cause);
+          await this.hooks.onEnqueueError({
+            envelope: item.envelope,
+            error: err,
+            transport: this.transport.name
+          });
+        }
+      } finally {
+        this.enqueuingCount--;
+      }
+    }
+    const remaining = this.retryBuffer.length;
+    if (remaining > 0) {
+      this.hooks.logger.warn(
+        `[Matador] \u{1F7E1} ${remaining} buffered message(s) could not be flushed; will retry on next reconnect.`
+      );
+    } else {
+      this.hooks.logger.info(
+        "[Matador] \u{1F7E2} All buffered messages flushed successfully."
+      );
+    }
+  }
   async isSubscriberEnabled(subscriber) {
     if (!subscriber.enabled) {
       return true;
@@ -2354,6 +2447,7 @@ var Matador = class {
     if (!this.started) {
       return;
     }
+    this.fanout.dispose();
     await this.shutdownManager.shutdown();
     this.started = false;
   }
@@ -2792,6 +2886,19 @@ var MultiTransport = class {
   isConnected() {
     return this.connected && this.primary.isConnected();
   }
+  /**
+   * Registers a callback to fire each time the transport successfully (re)connects
+   * @param callback - The callback to fire when the transport successfully (re)connects
+   * @returns A function to unsubscribe from the callback
+   */
+  onConnected(callback) {
+    const unsubFunctions = this.transports.map((t) => t.onConnected?.(callback)).filter(Boolean);
+    return () => {
+      for (const unsub of unsubFunctions) {
+        unsub();
+      }
+    };
+  }
   async applyTopology(topology) {
     await Promise.all(this.transports.map((t) => t.applyTopology(topology)));
   }
@@ -2941,6 +3048,18 @@ var RabbitMQTransport = class {
   isConnected() {
     return this.connectionManager.isConnected();
   }
+  /**
+   * Registers a callback to fire each time the transport (here RabbitMQ) successfully (re)connects
+   * @param callback - The callback to fire when the transport (here RabbitMQ) successfully (re)connects
+   * @returns A function to unsubscribe from the callback
+   */
+  onConnected(callback) {
+    return this.connectionManager.onStateChange((state) => {
+      if (state.status === "connected") {
+        callback();
+      }
+    });
+  }
   async applyTopology(topology) {
     this.topology = topology;
     if (!this.publishChannel) {
@@ -3219,6 +3338,14 @@ var RabbitMQTransport = class {
     return queueChannel;
   }
   async doConnect() {
+    if (this.connection) {
+      try {
+        await this.connection.close();
+      } catch {
+      }
+      this.connection = null;
+      this.publishChannel = null;
+    }
     this.queueChannels.clear();
     this.logger.info(
       `[Matador] \u23F3 Connecting to RabbitMQ at '${redactAmqpUrl(this.config.url)}'.`
@@ -3236,21 +3363,33 @@ var RabbitMQTransport = class {
           consumer.active = false;
         }
       }
+      this.connection = null;
+      this.publishChannel = null;
       if (this.connectionManager.isConnected()) {
         this.connectionManager.handleConnectionLost(
           new Error("Connection closed unexpectedly")
         );
       }
     });
-    this.publishChannel = await connection.createConfirmChannel();
-    this.publishChannel.on("error", (err) => {
-      this.logger.error("[Matador] \u{1F534} RabbitMQ publish channel error", err);
-    });
-    if (this.topology) {
-      await this.applyTopology(this.topology);
-      for (const intent of this.subscriptionIntents) {
-        await this.activateIntent(intent);
+    try {
+      this.publishChannel = await connection.createConfirmChannel();
+      this.publishChannel.on("error", (err) => {
+        this.logger.error("[Matador] \u{1F534} RabbitMQ publish channel error", err);
+      });
+      if (this.topology) {
+        await this.applyTopology(this.topology);
+        for (const intent of this.subscriptionIntents) {
+          await this.activateIntent(intent);
+        }
       }
+    } catch (err) {
+      try {
+        await connection.close();
+      } catch {
+      }
+      this.connection = null;
+      this.publishChannel = null;
+      throw err;
     }
     this.logger.info("[Matador] \u{1F50C} Connected to RabbitMQ");
   }