@a_jackie_z/event-bus 1.0.1

package/dist/chunk-5DMUVWFR.js

@@ -0,0 +1,151 @@
+import {
+  BaseEventBusConnection
+} from "./chunk-JBE5KWYZ.js";
+
+// lib/consumer.ts
+import { logger } from "@a_jackie_z/logger";
+var EventBusConsumer = class extends BaseEventBusConnection {
+  queueHandlers;
+  exchangeBindings;
+  activeConsumerTags = /* @__PURE__ */ new Set();
+  constructor(options) {
+    super(options);
+    this.queueHandlers = options.queueHandlers;
+    if (options.exchangeBindings !== void 0) {
+      this.exchangeBindings = options.exchangeBindings;
+    }
+  }
+  async createChannelAndSetup() {
+    if (!this.channelModel) {
+      throw new Error("Channel model is not initialized");
+    }
+    this.channel = await this.channelModel.createChannel();
+    this.channel.prefetch(1);
+    this.activeConsumerTags.clear();
+    for (const [queueName, handlers] of this.queueHandlers.entries()) {
+      const exchangeName = this.exchangeBindings?.get(queueName);
+      if (exchangeName) {
+        await this.channel.assertExchange(exchangeName, "fanout", {
+          durable: false,
+          // Exchange doesn't need to persist (stateless routing)
+          autoDelete: false
+          // Exchange is not auto-deleted
+        });
+        const { queue: exclusiveQueueName } = await this.channel.assertQueue("", {
+          exclusive: true,
+          // Queue is exclusive to this connection
+          autoDelete: true
+          // Queue is deleted when connection closes
+        });
+        await this.channel.bindQueue(exclusiveQueueName, exchangeName, "");
+        logger.info({ queueName, exchangeName, exclusiveQueueName }, "Queue bound to exchange for broadcast");
+        const { consumerTag } = await this.channel.consume(exclusiveQueueName, async (msg) => {
+          if (msg) {
+            let successCount = 0;
+            const content = msg.content.toString();
+            try {
+              const data = JSON.parse(content);
+              for (const handler of handlers) {
+                try {
+                  await handler(data);
+                  successCount++;
+                } catch (error) {
+                  logger.error({ error, queueName, exchangeName }, "Handler failed for broadcast queue");
+                }
+              }
+              if (successCount > 0) {
+                this.channel.ack(msg);
+              } else {
+                logger.error({ queueName, exchangeName, handlerCount: handlers.length }, "All handlers failed for broadcast queue");
+                this.channel.nack(msg, false, false);
+              }
+            } catch (error) {
+              logger.error({ error, queueName, exchangeName }, "Failed to parse message from broadcast queue");
+              this.channel.nack(msg, false, false);
+            }
+          }
+        }, {
+          noAck: false
+          // Require acknowledgment after processing
+        });
+        this.activeConsumerTags.add(consumerTag);
+        logger.info({ queueName, exchangeName, exclusiveQueueName, consumerTag }, "Consumer registered for broadcast queue");
+      } else {
+        await this.channel.assertQueue(queueName, {
+          durable: true,
+          // Queue persists after restart
+          exclusive: false,
+          // Multiple consumers can connect
+          autoDelete: false
+          // Queue is not auto-deleted
+        });
+        const { consumerTag } = await this.channel.consume(queueName, async (msg) => {
+          if (msg) {
+            let successCount = 0;
+            const content = msg.content.toString();
+            try {
+              const data = JSON.parse(content);
+              for (const handler of handlers) {
+                try {
+                  await handler(data);
+                  successCount++;
+                } catch (error) {
+                  logger.error({ error, queueName }, "Handler failed for queue");
+                }
+              }
+              if (successCount > 0) {
+                this.channel.ack(msg);
+              } else {
+                logger.error({ queueName, handlerCount: handlers.length }, "All handlers failed for queue, message will not be requeued");
+                this.channel.nack(msg, false, false);
+              }
+            } catch (error) {
+              logger.error({ error, queueName }, "Failed to parse message from queue");
+              this.channel.nack(msg, false, false);
+            }
+          }
+        }, {
+          noAck: false
+          // Require acknowledgment after processing
+        });
+        this.activeConsumerTags.add(consumerTag);
+        logger.info({ queueName, consumerTag }, "Consumer registered for queue");
+      }
+    }
+  }
+  async disconnect() {
+    logger.info("Disconnecting consumer");
+    if (this.channel && this.activeConsumerTags.size > 0) {
+      const cancelPromises = [];
+      for (const consumerTag of this.activeConsumerTags) {
+        const cancelPromise = (async () => {
+          try {
+            logger.debug({ consumerTag }, "Cancelling consumer");
+            await Promise.race([
+              this.channel.cancel(consumerTag),
+              new Promise(
+                (_, reject) => setTimeout(() => reject(new Error("Consumer cancellation timeout")), 5e3)
+              )
+            ]);
+          } catch (error) {
+            const errorMessage = error?.message || "";
+            if (errorMessage.includes("Channel ended") || errorMessage.includes("Channel closed") || errorMessage.includes("no reply will be forthcoming")) {
+              logger.debug({ consumerTag }, "Consumer already cancelled (channel closed)");
+            } else {
+              logger.error({ error, consumerTag }, "Failed to cancel consumer");
+            }
+          }
+        })();
+        cancelPromises.push(cancelPromise);
+      }
+      await Promise.allSettled(cancelPromises);
+    }
+    this.activeConsumerTags.clear();
+    await super.disconnect();
+  }
+};
+
+export {
+  EventBusConsumer
+};
+//# sourceMappingURL=chunk-5DMUVWFR.js.map

package/dist/chunk-5DMUVWFR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/consumer.ts"],"sourcesContent":["import amqplib from 'amqplib'\nimport { BaseEventBusConnection, ConnectionState } from './base-connection.js'\nimport { logger } from '@a_jackie_z/logger'\n\n// Type definitions\nexport type EventHandler<T = any> = (data: T) => Promise<void>;\nexport type QueueHandlers = Map<string, EventHandler[]>;\nexport type ExchangeBindings = Map<string, string>; // Map<queueName, exchangeName>\n\n// Re-export ConnectionState for backward compatibility\nexport { ConnectionState } from './base-connection.js'\n\nexport interface EventBusConsumerOptions {\n  rabbitMqUrl: string;\n  queueHandlers: QueueHandlers;\n  onStateChange?: (state: ConnectionState, reconnectCount?: number) => void;\n  exchangeBindings?: ExchangeBindings;\n}\n\nexport class EventBusConsumer extends BaseEventBusConnection<amqplib.Channel> {\n  private readonly queueHandlers: QueueHandlers;\n  private readonly exchangeBindings?: ExchangeBindings;\n  private activeConsumerTags: Set<string> = new Set();\n\n  constructor(options: EventBusConsumerOptions) {\n    super(options);\n    this.queueHandlers = options.queueHandlers;\n    if (options.exchangeBindings !== undefined) {\n      this.exchangeBindings = options.exchangeBindings;\n    }\n  }\n\n  protected async createChannelAndSetup(): Promise<void> {\n    if (!this.channelModel) {\n      throw new Error('Channel model is not initialized');\n    }\n\n    this.channel = await this.channelModel.createChannel();\n\n    // Limit to 1 message processed at a time\n    this.channel.prefetch(1);\n\n    // Clear active consumer tags on reconnect\n    this.activeConsumerTags.clear();\n\n    // Assert queues and register handlers\n    for (const [queueName, handlers] of this.queueHandlers.entries()) {\n      // Check if this queue should be bound to an exchange (broadcast mode)\n      const exchangeName = this.exchangeBindings?.get(queueName);\n\n      if (exchangeName) {\n        // Broadcast mode: assert exchange and create exclusive queue\n        await this.channel.assertExchange(exchangeName, 'fanout', {\n          durable: false,       // Exchange doesn't need to persist (stateless routing)\n          autoDelete: false     // Exchange is not auto-deleted\n        });\n\n        // Create exclusive queue that gets deleted when consumer disconnects\n        // This ensures each consumer instance receives all broadcast messages\n        const { queue: exclusiveQueueName } = await this.channel.assertQueue('', {\n          exclusive: true,      // Queue is exclusive to this connection\n          autoDelete: true      // Queue is deleted when connection closes\n        });\n\n        // Bind the exclusive queue to the fanout exchange\n        await this.channel.bindQueue(exclusiveQueueName, exchangeName, '');\n\n        logger.info({ queueName, exchangeName, exclusiveQueueName }, 'Queue bound to exchange for broadcast');\n\n        // Setup consumer for the exclusive queue\n        const { consumerTag } = await this.channel.consume(exclusiveQueueName, async (msg) => {\n          if (msg) {\n            let successCount = 0;\n            const content = msg.content.toString();\n\n            try {\n              const data = JSON.parse(content);\n\n              // Execute handlers sequentially\n              for (const handler of handlers) {\n                try {\n                  await handler(data);\n                  successCount++;\n                } catch (error) {\n                  logger.error({ error, queueName, exchangeName }, 'Handler failed for broadcast queue');\n                }\n              }\n\n              // Acknowledge if at least one handler succeeded\n              if (successCount > 0) {\n                this.channel!.ack(msg);\n              } else {\n                // All handlers failed, nack without requeue\n                logger.error({ queueName, exchangeName, handlerCount: handlers.length }, 'All handlers failed for broadcast queue');\n                this.channel!.nack(msg, false, false);\n              }\n            } catch (error) {\n              logger.error({ error, queueName, exchangeName }, 'Failed to parse message from broadcast queue');\n              this.channel!.nack(msg, false, false);\n            }\n          }\n        }, {\n          noAck: false // Require acknowledgment after processing\n        });\n\n        this.activeConsumerTags.add(consumerTag);\n        logger.info({ queueName, exchangeName, exclusiveQueueName, consumerTag }, 'Consumer registered for broadcast queue');\n      } else {\n        // Direct queue mode: traditional point-to-point messaging\n        await this.channel.assertQueue(queueName, {\n          durable: true,        // Queue persists after restart\n          exclusive: false,     // Multiple consumers can connect\n          autoDelete: false     // Queue is not auto-deleted\n        });\n\n        // Setup consumer for this queue\n        const { consumerTag } = await this.channel.consume(queueName, async (msg) => {\n          if (msg) {\n            let successCount = 0;\n            const content = msg.content.toString();\n\n            try {\n              const data = JSON.parse(content);\n\n              // Execute handlers sequentially\n              for (const handler of handlers) {\n                try {\n                  await handler(data);\n                  successCount++;\n                } catch (error) {\n                  logger.error({ error, queueName }, 'Handler failed for queue');\n                }\n              }\n\n              // Acknowledge if at least one handler succeeded\n              if (successCount > 0) {\n                this.channel!.ack(msg);\n              } else {\n                // All handlers failed, nack without requeue\n                logger.error({ queueName, handlerCount: handlers.length }, 'All handlers failed for queue, message will not be requeued');\n                this.channel!.nack(msg, false, false);\n              }\n            } catch (error) {\n              logger.error({ error, queueName }, 'Failed to parse message from queue');\n              this.channel!.nack(msg, false, false);\n            }\n          }\n        }, {\n          noAck: false // Require acknowledgment after processing\n        });\n\n        this.activeConsumerTags.add(consumerTag);\n        logger.info({ queueName, consumerTag }, 'Consumer registered for queue');\n      }\n    }\n  }\n\n  override async disconnect() {\n    logger.info('Disconnecting consumer');\n\n    // Cancel all active consumers gracefully before base disconnect\n    if (this.channel && this.activeConsumerTags.size > 0) {\n      const cancelPromises: Promise<void>[] = [];\n\n      for (const consumerTag of this.activeConsumerTags) {\n        const cancelPromise = (async () => {\n          try {\n            logger.debug({ consumerTag }, 'Cancelling consumer');\n\n            // Apply timeout only if channel operation can be initiated\n            await Promise.race([\n              this.channel!.cancel(consumerTag),\n              new Promise<void>((_, reject) =>\n                setTimeout(() => reject(new Error('Consumer cancellation timeout')), 5000)\n              )\n            ]);\n          } catch (error: any) {\n            // Gracefully handle channel-closed errors (expected during shutdown)\n            const errorMessage = error?.message || '';\n            if (errorMessage.includes('Channel ended') ||\n                errorMessage.includes('Channel closed') ||\n                errorMessage.includes('no reply will be forthcoming')) {\n              logger.debug({ consumerTag }, 'Consumer already cancelled (channel closed)');\n            } else {\n              logger.error({ error, consumerTag }, 'Failed to cancel consumer');\n            }\n          }\n        })();\n\n        cancelPromises.push(cancelPromise);\n      }\n\n      // Wait for all cancellations to complete or fail\n      await Promise.allSettled(cancelPromises);\n    }\n\n    this.activeConsumerTags.clear();\n\n    // Call base class disconnect to close channel and connection\n    await super.disconnect();\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-JBE5KWYZ.js

@@ -0,0 +1,131 @@
+// lib/base-connection.ts
+import amqplib from "amqplib";
+import { logger } from "@a_jackie_z/logger";
+var ConnectionState = {
+  CONNECTED: "CONNECTED",
+  DISCONNECTED: "DISCONNECTED",
+  RECONNECTING: "RECONNECTING"
+};
+var BaseEventBusConnection = class {
+  channelModel = null;
+  channel = null;
+  rabbitMqUrl;
+  onStateChange;
+  reconnectTimer = null;
+  isReconnecting = false;
+  shouldReconnect = true;
+  reconnectCount = 0;
+  constructor(options) {
+    this.rabbitMqUrl = options.rabbitMqUrl;
+    this.onStateChange = options.onStateChange;
+  }
+  async connect() {
+    try {
+      this.channelModel = await amqplib.connect(this.rabbitMqUrl);
+      this.channelModel.on("error", (error) => {
+        logger.error({ error }, "RabbitMQ connection error");
+        this.scheduleReconnect();
+      });
+      this.channelModel.on("close", () => {
+        logger.debug("RabbitMQ connection closed");
+        this.scheduleReconnect();
+      });
+      await this.createChannelAndSetup();
+      if (this.channel) {
+        this.channel.on("error", (error) => {
+          logger.error({ error }, "RabbitMQ channel error");
+          this.scheduleReconnect();
+        });
+        this.channel.on("close", () => {
+          logger.debug("RabbitMQ channel closed");
+          this.scheduleReconnect();
+        });
+      }
+      this.reconnectCount = 0;
+      this.isReconnecting = false;
+      this.notifyStateChange(ConnectionState.CONNECTED);
+      logger.info({ state: ConnectionState.CONNECTED }, "RabbitMQ connection established successfully");
+      return this.channel;
+    } catch (error) {
+      logger.error({ error }, "Failed to connect to RabbitMQ");
+      this.scheduleReconnect();
+      throw error;
+    }
+  }
+  scheduleReconnect() {
+    if (!this.shouldReconnect || this.isReconnecting) {
+      return;
+    }
+    this.isReconnecting = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    this.reconnectCount++;
+    this.notifyStateChange(ConnectionState.RECONNECTING, this.reconnectCount);
+    logger.info({ reconnectCount: this.reconnectCount, state: ConnectionState.RECONNECTING }, "Reconnection attempt scheduled in 15 seconds");
+    this.reconnectTimer = setTimeout(async () => {
+      await this.reconnect();
+    }, 15e3);
+  }
+  async reconnect() {
+    try {
+      logger.info({ reconnectCount: this.reconnectCount }, "Attempting to reconnect");
+      this.channel = null;
+      this.channelModel = null;
+      await this.connect();
+    } catch (error) {
+      logger.error({ error, reconnectCount: this.reconnectCount }, "Reconnection failed");
+      this.isReconnecting = false;
+      this.scheduleReconnect();
+    }
+  }
+  notifyStateChange(state, reconnectCount) {
+    if (this.onStateChange) {
+      try {
+        this.onStateChange(state, reconnectCount);
+      } catch (error) {
+        logger.error({ error }, "Error in state change callback");
+      }
+    }
+  }
+  async disconnect() {
+    logger.info({ state: ConnectionState.DISCONNECTED }, "Disconnecting from RabbitMQ");
+    this.shouldReconnect = false;
+    this.notifyStateChange(ConnectionState.DISCONNECTED);
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.channel) {
+      try {
+        await this.channel.close();
+      } catch (error) {
+        const errorMessage = error?.message || "";
+        if (errorMessage.includes("Channel closed") || errorMessage.includes("IllegalOperationError")) {
+          logger.debug("Channel already closed");
+        } else {
+          logger.error({ error }, "Error closing channel");
+        }
+      }
+    }
+    if (this.channelModel) {
+      try {
+        await this.channelModel.close();
+      } catch (error) {
+        const errorMessage = error?.message || "";
+        if (errorMessage.includes("Connection closed") || errorMessage.includes("Connection closing") || errorMessage.includes("IllegalOperationError")) {
+          logger.debug("Connection already closed or closing");
+        } else {
+          logger.error({ error }, "Error closing connection");
+        }
+      }
+    }
+    logger.info("Disconnected from RabbitMQ");
+  }
+};
+
+export {
+  ConnectionState,
+  BaseEventBusConnection
+};
+//# sourceMappingURL=chunk-JBE5KWYZ.js.map

package/dist/chunk-JBE5KWYZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/base-connection.ts"],"sourcesContent":["import amqplib from 'amqplib'\nimport { logger } from '@a_jackie_z/logger'\n\nexport const ConnectionState = {\n  CONNECTED: 'CONNECTED',\n  DISCONNECTED: 'DISCONNECTED',\n  RECONNECTING: 'RECONNECTING'\n} as const;\n\nexport type ConnectionState = typeof ConnectionState[keyof typeof ConnectionState];\n\nexport interface BaseEventBusConnectionOptions {\n  rabbitMqUrl: string;\n  onStateChange?: (state: ConnectionState, reconnectCount?: number) => void;\n}\n\nexport abstract class BaseEventBusConnection<T extends amqplib.Channel> {\n  protected channelModel: amqplib.ChannelModel | null = null;\n  protected channel: T | null = null;\n  protected readonly rabbitMqUrl: string;\n  protected readonly onStateChange: ((state: ConnectionState, reconnectCount?: number) => void) | undefined;\n  protected reconnectTimer: NodeJS.Timeout | null = null;\n  protected isReconnecting: boolean = false;\n  protected shouldReconnect: boolean = true;\n  protected reconnectCount: number = 0;\n\n  constructor(options: BaseEventBusConnectionOptions) {\n    this.rabbitMqUrl = options.rabbitMqUrl;\n    this.onStateChange = options.onStateChange;\n  }\n\n  /**\n   * Abstract method for creating and setting up the channel.\n   * Subclasses must implement this to define their specific channel type and setup logic.\n   */\n  protected abstract createChannelAndSetup(): Promise<void>;\n\n  async connect() {\n    try {\n      this.channelModel = await amqplib.connect(this.rabbitMqUrl);\n\n      // Setup connection error handlers\n      this.channelModel.on('error', (error) => {\n        logger.error({ error }, 'RabbitMQ connection error');\n        this.scheduleReconnect();\n      });\n\n      this.channelModel.on('close', () => {\n        logger.debug('RabbitMQ connection closed');\n        this.scheduleReconnect();\n      });\n\n      // Create and setup channel (subclass-specific)\n      await this.createChannelAndSetup();\n\n      // Setup channel error handlers\n      if (this.channel) {\n        this.channel.on('error', (error) => {\n          logger.error({ error }, 'RabbitMQ channel error');\n          this.scheduleReconnect();\n        });\n\n        this.channel.on('close', () => {\n          logger.debug('RabbitMQ channel closed');\n          this.scheduleReconnect();\n        });\n      }\n\n      // Reset reconnect count on successful connection\n      this.reconnectCount = 0;\n      this.isReconnecting = false;\n\n      // Notify state change\n      this.notifyStateChange(ConnectionState.CONNECTED);\n\n      logger.info({ state: ConnectionState.CONNECTED }, 'RabbitMQ connection established successfully');\n      return this.channel;\n    } catch (error) {\n      logger.error({ error }, 'Failed to connect to RabbitMQ');\n      this.scheduleReconnect();\n      throw error;\n    }\n  }\n\n  protected scheduleReconnect() {\n    if (!this.shouldReconnect || this.isReconnecting) {\n      return;\n    }\n\n    this.isReconnecting = true;\n\n    // Clear existing timer\n    if (this.reconnectTimer) {\n      clearTimeout(this.reconnectTimer);\n    }\n\n    this.reconnectCount++;\n\n    // Notify state change\n    this.notifyStateChange(ConnectionState.RECONNECTING, this.reconnectCount);\n\n    logger.info({ reconnectCount: this.reconnectCount, state: ConnectionState.RECONNECTING }, 'Reconnection attempt scheduled in 15 seconds');\n\n    this.reconnectTimer = setTimeout(async () => {\n      await this.reconnect();\n    }, 15000);\n  }\n\n  protected async reconnect() {\n    try {\n      logger.info({ reconnectCount: this.reconnectCount }, 'Attempting to reconnect');\n\n      // Nullify existing connections\n      this.channel = null;\n      this.channelModel = null;\n\n      // Attempt to reconnect\n      await this.connect();\n    } catch (error) {\n      logger.error({ error, reconnectCount: this.reconnectCount }, 'Reconnection failed');\n      this.isReconnecting = false;\n      this.scheduleReconnect();\n    }\n  }\n\n  protected notifyStateChange(state: ConnectionState, reconnectCount?: number) {\n    if (this.onStateChange) {\n      try {\n        this.onStateChange(state, reconnectCount);\n      } catch (error) {\n        logger.error({ error }, 'Error in state change callback');\n      }\n    }\n  }\n\n  async disconnect() {\n    logger.info({ state: ConnectionState.DISCONNECTED }, 'Disconnecting from RabbitMQ');\n\n    this.shouldReconnect = false;\n\n    // Notify state change\n    this.notifyStateChange(ConnectionState.DISCONNECTED);\n\n    // Clear reconnection timer\n    if (this.reconnectTimer) {\n      clearTimeout(this.reconnectTimer);\n      this.reconnectTimer = null;\n    }\n\n    // Close channel and connection\n    if (this.channel) {\n      try {\n        await this.channel.close();\n      } catch (error: any) {\n        // Ignore errors if channel is already closed\n        const errorMessage = error?.message || '';\n        if (errorMessage.includes('Channel closed') ||\n            errorMessage.includes('IllegalOperationError')) {\n          logger.debug('Channel already closed');\n        } else {\n          logger.error({ error }, 'Error closing channel');\n        }\n      }\n    }\n\n    if (this.channelModel) {\n      try {\n        await this.channelModel.close();\n      } catch (error: any) {\n        // Ignore errors if connection is already closed or closing\n        const errorMessage = error?.message || '';\n        if (errorMessage.includes('Connection closed') ||\n            errorMessage.includes('Connection closing') ||\n            errorMessage.includes('IllegalOperationError')) {\n          logger.debug('Connection already closed or closing');\n        } else {\n          logger.error({ error }, 'Error closing connection');\n        }\n      }\n    }\n\n    logger.info('Disconnected from RabbitMQ');\n  }\n}\n"],"mappings":";AAAA,OAAO,aAAa;AACpB,SAAS,cAAc;AAEhB,IAAM,kBAAkB;AAAA,EAC7B,WAAW;AAAA,EACX,cAAc;AAAA,EACd,cAAc;AAChB;AASO,IAAe,yBAAf,MAAiE;AAAA,EAC5D,eAA4C;AAAA,EAC5C,UAAoB;AAAA,EACX;AAAA,EACA;AAAA,EACT,iBAAwC;AAAA,EACxC,iBAA0B;AAAA,EAC1B,kBAA2B;AAAA,EAC3B,iBAAyB;AAAA,EAEnC,YAAY,SAAwC;AAClD,SAAK,cAAc,QAAQ;AAC3B,SAAK,gBAAgB,QAAQ;AAAA,EAC/B;AAAA,EAQA,MAAM,UAAU;AACd,QAAI;AACF,WAAK,eAAe,MAAM,QAAQ,QAAQ,KAAK,WAAW;AAG1D,WAAK,aAAa,GAAG,SAAS,CAAC,UAAU;AACvC,eAAO,MAAM,EAAE,MAAM,GAAG,2BAA2B;AACnD,aAAK,kBAAkB;AAAA,MACzB,CAAC;AAED,WAAK,aAAa,GAAG,SAAS,MAAM;AAClC,eAAO,MAAM,4BAA4B;AACzC,aAAK,kBAAkB;AAAA,MACzB,CAAC;AAGD,YAAM,KAAK,sBAAsB;AAGjC,UAAI,KAAK,SAAS;AAChB,aAAK,QAAQ,GAAG,SAAS,CAAC,UAAU;AAClC,iBAAO,MAAM,EAAE,MAAM,GAAG,wBAAwB;AAChD,eAAK,kBAAkB;AAAA,QACzB,CAAC;AAED,aAAK,QAAQ,GAAG,SAAS,MAAM;AAC7B,iBAAO,MAAM,yBAAyB;AACtC,eAAK,kBAAkB;AAAA,QACzB,CAAC;AAAA,MACH;AAGA,WAAK,iBAAiB;AACtB,WAAK,iBAAiB;AAGtB,WAAK,kBAAkB,gBAAgB,SAAS;AAEhD,aAAO,KAAK,EAAE,OAAO,gBAAgB,UAAU,GAAG,8CAA8C;AAChG,aAAO,KAAK;AAAA,IACd,SAAS,OAAO;AACd,aAAO,MAAM,EAAE,MAAM,GAAG,+BAA+B;AACvD,WAAK,kBAAkB;AACvB,YAAM;AAAA,IACR;AAAA,EACF;AAAA,EAEU,oBAAoB;AAC5B,QAAI,CAAC,KAAK,mBAAmB,KAAK,gBAAgB;AAChD;AAAA,IACF;AAEA,SAAK,iBAAiB;AAGtB,QAAI,KAAK,gBAAgB;AACvB,mBAAa,KAAK,cAAc;AAAA,IAClC;AAEA,SAAK;AAGL,SAAK,kBAAkB,gBAAgB,cAAc,KAAK,cAAc;AAExE,WAAO,KAAK,EAAE,gBAAgB,KAAK,gBAAgB,OAAO,gBAAgB,aAAa,GAAG,8CAA8C;AAExI,SAAK,iBAAiB,WAAW,YAAY;AAC3C,YAAM,KAAK,UAAU;AAAA,IACvB,GAAG,IAAK;AAAA,EACV;AAAA,EAEA,MAAgB,YAAY;AAC1B,QAAI;AACF,aAAO,KAAK,EAAE,gBAAgB,KAAK,eAAe,GAAG,yBAAyB;AAG9E,WAAK,UAAU;AACf,WAAK,eAAe;AAGpB,YAAM,KAAK,QAAQ;AAAA,IACrB,SAAS,OAAO;AACd,aAAO,MAAM,EAAE,OAAO,gBAAgB,KAAK,eAAe,GAAG,qBAAqB;AAClF,WAAK,iBAAiB;AACtB,WAAK,kBAAkB;AAAA,IACzB;AAAA,EACF;AAAA,EAEU,kBAAkB,OAAwB,gBAAyB;AAC3E,QAAI,KAAK,eAAe;AACtB,UAAI;AACF,aAAK,cAAc,OAAO,cAAc;AAAA,MAC1C,SAAS,OAAO;AACd,eAAO,MAAM,EAAE,MAAM,GAAG,gCAAgC;AAAA,MAC1D;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,aAAa;AACjB,WAAO,KAAK,EAAE,OAAO,gBAAgB,aAAa,GAAG,6BAA6B;AAElF,SAAK,kBAAkB;AAGvB,SAAK,kBAAkB,gBAAgB,YAAY;AAGnD,QAAI,KAAK,gBAAgB;AACvB,mBAAa,KAAK,cAAc;AAChC,WAAK,iBAAiB;AAAA,IACxB;AAGA,QAAI,KAAK,SAAS;AAChB,UAAI;AACF,cAAM,KAAK,QAAQ,MAAM;AAAA,MAC3B,SAAS,OAAY;AAEnB,cAAM,eAAe,OAAO,WAAW;AACvC,YAAI,aAAa,SAAS,gBAAgB,KACtC,aAAa,SAAS,uBAAuB,GAAG;AAClD,iBAAO,MAAM,wBAAwB;AAAA,QACvC,OAAO;AACL,iBAAO,MAAM,EAAE,MAAM,GAAG,uBAAuB;AAAA,QACjD;AAAA,MACF;AAAA,IACF;AAEA,QAAI,KAAK,cAAc;AACrB,UAAI;AACF,cAAM,KAAK,aAAa,MAAM;AAAA,MAChC,SAAS,OAAY;AAEnB,cAAM,eAAe,OAAO,WAAW;AACvC,YAAI,aAAa,SAAS,mBAAmB,KACzC,aAAa,SAAS,oBAAoB,KAC1C,aAAa,SAAS,uBAAuB,GAAG;AAClD,iBAAO,MAAM,sCAAsC;AAAA,QACrD,OAAO;AACL,iBAAO,MAAM,EAAE,MAAM,GAAG,0BAA0B;AAAA,QACpD;AAAA,MACF;AAAA,IACF;AAEA,WAAO,KAAK,4BAA4B;AAAA,EAC1C;AACF;","names":[]}

package/dist/chunk-YP7YVSEN.js

@@ -0,0 +1,88 @@
+import {
+  BaseEventBusConnection
+} from "./chunk-JBE5KWYZ.js";
+
+// lib/producer.ts
+import { logger } from "@a_jackie_z/logger";
+var EventBusProducer = class extends BaseEventBusConnection {
+  constructor(options) {
+    super(options);
+  }
+  async createChannelAndSetup() {
+    if (!this.channelModel) {
+      throw new Error("Channel model is not initialized");
+    }
+    this.channel = await this.channelModel.createConfirmChannel();
+    logger.debug("RabbitMQ confirm channel created successfully");
+  }
+  /**
+   * Publish a message to a queue with persistence enabled.
+   * Throws immediately if channel is not available.
+   *
+   * @param queueName The name of the queue to publish to
+   * @param data The data to publish
+   * @throws Error if channel is not available or publish fails
+   */
+  async publish(queueName, data) {
+    if (!this.channel) {
+      throw new Error("Channel is not available. Ensure connect() is called and connection is established.");
+    }
+    try {
+      await this.channel.assertQueue(queueName, {
+        durable: true,
+        // Queue persists after restart
+        exclusive: false,
+        // Multiple producers/consumers can connect
+        autoDelete: false
+        // Queue is not auto-deleted
+      });
+      const message = JSON.stringify(data);
+      this.channel.sendToQueue(queueName, Buffer.from(message), {
+        persistent: true
+        // Message survives broker restart
+      });
+      await this.channel.waitForConfirms();
+      logger.debug({ queueName, data }, "Message published to queue");
+    } catch (error) {
+      logger.error({ error, queueName }, "Failed to publish message to queue");
+      throw error;
+    }
+  }
+  /**
+   * Broadcast a message to all consumers listening on the exchange.
+   * Uses fanout exchange to deliver message to all bound queues.
+   * Throws immediately if channel is not available.
+   *
+   * @param exchangeName The name of the fanout exchange to broadcast to
+   * @param data The data to broadcast
+   * @throws Error if channel is not available or broadcast fails
+   */
+  async broadcast(exchangeName, data) {
+    if (!this.channel) {
+      throw new Error("Channel is not available. Ensure connect() is called and connection is established.");
+    }
+    try {
+      await this.channel.assertExchange(exchangeName, "fanout", {
+        durable: false,
+        // Exchange doesn't need to persist (stateless routing)
+        autoDelete: false
+        // Exchange is not auto-deleted
+      });
+      const message = JSON.stringify(data);
+      this.channel.publish(exchangeName, "", Buffer.from(message), {
+        persistent: false
+        // Transient messages for broadcast (not persisted)
+      });
+      await this.channel.waitForConfirms();
+      logger.debug({ exchangeName, data }, "Message broadcast to exchange");
+    } catch (error) {
+      logger.error({ error, exchangeName }, "Failed to broadcast message to exchange");
+      throw error;
+    }
+  }
+};
+
+export {
+  EventBusProducer
+};
+//# sourceMappingURL=chunk-YP7YVSEN.js.map

package/dist/chunk-YP7YVSEN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/producer.ts"],"sourcesContent":["import amqplib from 'amqplib'\nimport { BaseEventBusConnection, ConnectionState } from './base-connection.js'\nimport { logger } from '@a_jackie_z/logger'\n\n// Re-export ConnectionState for convenience\nexport { ConnectionState } from './base-connection.js'\n\nexport interface EventBusProducerOptions {\n  rabbitMqUrl: string;\n  onStateChange?: (state: ConnectionState, reconnectCount?: number) => void;\n}\n\nexport class EventBusProducer extends BaseEventBusConnection<amqplib.ConfirmChannel> {\n  constructor(options: EventBusProducerOptions) {\n    super(options);\n  }\n\n  protected async createChannelAndSetup(): Promise<void> {\n    if (!this.channelModel) {\n      throw new Error('Channel model is not initialized');\n    }\n\n    // Create confirm channel for reliable publishing\n    this.channel = await this.channelModel.createConfirmChannel();\n    logger.debug('RabbitMQ confirm channel created successfully');\n  }\n\n  /**\n   * Publish a message to a queue with persistence enabled.\n   * Throws immediately if channel is not available.\n   *\n   * @param queueName The name of the queue to publish to\n   * @param data The data to publish\n   * @throws Error if channel is not available or publish fails\n   */\n  async publish(queueName: string, data: any): Promise<void> {\n    if (!this.channel) {\n      throw new Error('Channel is not available. Ensure connect() is called and connection is established.');\n    }\n\n    try {\n      // Assert queue with durable option\n      await this.channel.assertQueue(queueName, {\n        durable: true,        // Queue persists after restart\n        exclusive: false,     // Multiple producers/consumers can connect\n        autoDelete: false     // Queue is not auto-deleted\n      });\n\n      // Send message with persistent flag\n      const message = JSON.stringify(data);\n      this.channel.sendToQueue(queueName, Buffer.from(message), {\n        persistent: true  // Message survives broker restart\n      });\n\n      // Wait for broker confirmation\n      await this.channel.waitForConfirms();\n\n      logger.debug({ queueName, data }, 'Message published to queue');\n    } catch (error) {\n      logger.error({ error, queueName }, 'Failed to publish message to queue');\n      throw error;\n    }\n  }\n\n  /**\n   * Broadcast a message to all consumers listening on the exchange.\n   * Uses fanout exchange to deliver message to all bound queues.\n   * Throws immediately if channel is not available.\n   *\n   * @param exchangeName The name of the fanout exchange to broadcast to\n   * @param data The data to broadcast\n   * @throws Error if channel is not available or broadcast fails\n   */\n  async broadcast(exchangeName: string, data: any): Promise<void> {\n    if (!this.channel) {\n      throw new Error('Channel is not available. Ensure connect() is called and connection is established.');\n    }\n\n    try {\n      // Assert fanout exchange\n      await this.channel.assertExchange(exchangeName, 'fanout', {\n        durable: false,       // Exchange doesn't need to persist (stateless routing)\n        autoDelete: false     // Exchange is not auto-deleted\n      });\n\n      // Broadcast message to exchange (no routing key needed for fanout)\n      const message = JSON.stringify(data);\n      this.channel.publish(exchangeName, '', Buffer.from(message), {\n        persistent: false  // Transient messages for broadcast (not persisted)\n      });\n\n      // Wait for broker confirmation\n      await this.channel.waitForConfirms();\n\n      logger.debug({ exchangeName, data }, 'Message broadcast to exchange');\n    } catch (error) {\n      logger.error({ error, exchangeName }, 'Failed to broadcast message to exchange');\n      throw error;\n    }\n  }\n}\n"],"mappings":";;;;;AAEA,SAAS,cAAc;AAUhB,IAAM,mBAAN,cAA+B,uBAA+C;AAAA,EACnF,YAAY,SAAkC;AAC5C,UAAM,OAAO;AAAA,EACf;AAAA,EAEA,MAAgB,wBAAuC;AACrD,QAAI,CAAC,KAAK,cAAc;AACtB,YAAM,IAAI,MAAM,kCAAkC;AAAA,IACpD;AAGA,SAAK,UAAU,MAAM,KAAK,aAAa,qBAAqB;AAC5D,WAAO,MAAM,+CAA+C;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAM,QAAQ,WAAmB,MAA0B;AACzD,QAAI,CAAC,KAAK,SAAS;AACjB,YAAM,IAAI,MAAM,qFAAqF;AAAA,IACvG;AAEA,QAAI;AAEF,YAAM,KAAK,QAAQ,YAAY,WAAW;AAAA,QACxC,SAAS;AAAA;AAAA,QACT,WAAW;AAAA;AAAA,QACX,YAAY;AAAA;AAAA,MACd,CAAC;AAGD,YAAM,UAAU,KAAK,UAAU,IAAI;AACnC,WAAK,QAAQ,YAAY,WAAW,OAAO,KAAK,OAAO,GAAG;AAAA,QACxD,YAAY;AAAA;AAAA,MACd,CAAC;AAGD,YAAM,KAAK,QAAQ,gBAAgB;AAEnC,aAAO,MAAM,EAAE,WAAW,KAAK,GAAG,4BAA4B;AAAA,IAChE,SAAS,OAAO;AACd,aAAO,MAAM,EAAE,OAAO,UAAU,GAAG,oCAAoC;AACvE,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAM,UAAU,cAAsB,MAA0B;AAC9D,QAAI,CAAC,KAAK,SAAS;AACjB,YAAM,IAAI,MAAM,qFAAqF;AAAA,IACvG;AAEA,QAAI;AAEF,YAAM,KAAK,QAAQ,eAAe,cAAc,UAAU;AAAA,QACxD,SAAS;AAAA;AAAA,QACT,YAAY;AAAA;AAAA,MACd,CAAC;AAGD,YAAM,UAAU,KAAK,UAAU,IAAI;AACnC,WAAK,QAAQ,QAAQ,cAAc,IAAI,OAAO,KAAK,OAAO,GAAG;AAAA,QAC3D,YAAY;AAAA;AAAA,MACd,CAAC;AAGD,YAAM,KAAK,QAAQ,gBAAgB;AAEnC,aAAO,MAAM,EAAE,cAAc,KAAK,GAAG,+BAA+B;AAAA,IACtE,SAAS,OAAO;AACd,aAAO,MAAM,EAAE,OAAO,aAAa,GAAG,yCAAyC;AAC/E,YAAM;AAAA,IACR;AAAA,EACF;AACF;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+import amqplib from 'amqplib';
+
+declare const ConnectionState: {
+    readonly CONNECTED: "CONNECTED";
+    readonly DISCONNECTED: "DISCONNECTED";
+    readonly RECONNECTING: "RECONNECTING";
+};
+type ConnectionState = typeof ConnectionState[keyof typeof ConnectionState];
+interface BaseEventBusConnectionOptions {
+    rabbitMqUrl: string;
+    onStateChange?: (state: ConnectionState, reconnectCount?: number) => void;
+}
+declare abstract class BaseEventBusConnection<T extends amqplib.Channel> {
+    protected channelModel: amqplib.ChannelModel | null;
+    protected channel: T | null;
+    protected readonly rabbitMqUrl: string;
+    protected readonly onStateChange: ((state: ConnectionState, reconnectCount?: number) => void) | undefined;
+    protected reconnectTimer: NodeJS.Timeout | null;
+    protected isReconnecting: boolean;
+    protected shouldReconnect: boolean;
+    protected reconnectCount: number;
+    constructor(options: BaseEventBusConnectionOptions);
+    /**
+     * Abstract method for creating and setting up the channel.
+     * Subclasses must implement this to define their specific channel type and setup logic.
+     */
+    protected abstract createChannelAndSetup(): Promise<void>;
+    connect(): Promise<T | null>;
+    protected scheduleReconnect(): void;
+    protected reconnect(): Promise<void>;
+    protected notifyStateChange(state: ConnectionState, reconnectCount?: number): void;
+    disconnect(): Promise<void>;
+}
+
+type EventHandler<T = any> = (data: T) => Promise<void>;
+type QueueHandlers = Map<string, EventHandler[]>;
+type ExchangeBindings = Map<string, string>;
+
+interface EventBusConsumerOptions {
+    rabbitMqUrl: string;
+    queueHandlers: QueueHandlers;
+    onStateChange?: (state: ConnectionState, reconnectCount?: number) => void;
+    exchangeBindings?: ExchangeBindings;
+}
+declare class EventBusConsumer extends BaseEventBusConnection<amqplib.Channel> {
+    private readonly queueHandlers;
+    private readonly exchangeBindings?;
+    private activeConsumerTags;
+    constructor(options: EventBusConsumerOptions);
+    protected createChannelAndSetup(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+
+interface EventBusProducerOptions {
+    rabbitMqUrl: string;
+    onStateChange?: (state: ConnectionState, reconnectCount?: number) => void;
+}
+declare class EventBusProducer extends BaseEventBusConnection<amqplib.ConfirmChannel> {
+    constructor(options: EventBusProducerOptions);
+    protected createChannelAndSetup(): Promise<void>;
+    /**
+     * Publish a message to a queue with persistence enabled.
+     * Throws immediately if channel is not available.
+     *
+     * @param queueName The name of the queue to publish to
+     * @param data The data to publish
+     * @throws Error if channel is not available or publish fails
+     */
+    publish(queueName: string, data: any): Promise<void>;
+    /**
+     * Broadcast a message to all consumers listening on the exchange.
+     * Uses fanout exchange to deliver message to all bound queues.
+     * Throws immediately if channel is not available.
+     *
+     * @param exchangeName The name of the fanout exchange to broadcast to
+     * @param data The data to broadcast
+     * @throws Error if channel is not available or broadcast fails
+     */
+    broadcast(exchangeName: string, data: any): Promise<void>;
+}
+
+export { BaseEventBusConnection, type BaseEventBusConnectionOptions, ConnectionState, EventBusConsumer, type EventBusConsumerOptions, EventBusProducer, type EventBusProducerOptions, type EventHandler, type ExchangeBindings, type QueueHandlers };

package/dist/index.js

@@ -0,0 +1,17 @@
+import {
+  EventBusConsumer
+} from "./chunk-5DMUVWFR.js";
+import {
+  EventBusProducer
+} from "./chunk-YP7YVSEN.js";
+import {
+  BaseEventBusConnection,
+  ConnectionState
+} from "./chunk-JBE5KWYZ.js";
+export {
+  BaseEventBusConnection,
+  ConnectionState,
+  EventBusConsumer,
+  EventBusProducer
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/lib/tests/broadcast-consumer.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/lib/tests/broadcast-consumer.js

@@ -0,0 +1,112 @@
+import {
+  EventBusConsumer
+} from "../../chunk-5DMUVWFR.js";
+import "../../chunk-JBE5KWYZ.js";
+
+// lib/tests/broadcast-consumer.ts
+import { logger } from "@a_jackie_z/logger";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var isChildConsumer = process.env.IS_CHILD_CONSUMER === "true";
+var consumerId = process.env.CONSUMER_ID || "1";
+if (isChildConsumer) {
+  const notificationHandler = async (data) => {
+    logger.info({ data, consumerId }, `[Consumer ${consumerId}] Received broadcast notification`);
+  };
+  const alertHandler = async (data) => {
+    logger.info({ data, consumerId }, `[Consumer ${consumerId}] Received broadcast alert`);
+  };
+  const queueHandlers = /* @__PURE__ */ new Map([
+    ["notifications", [notificationHandler]],
+    ["alerts", [alertHandler]]
+  ]);
+  const exchangeBindings = /* @__PURE__ */ new Map([
+    ["notifications", "notification_broadcast"],
+    ["alerts", "alert_broadcast"]
+  ]);
+  const consumer = new EventBusConsumer({
+    rabbitMqUrl: "amqp://rabbitmq:12345678@192.168.2.151:5672",
+    queueHandlers,
+    onStateChange: (state, reconnectCount) => {
+      logger.info({ state, reconnectCount, consumerId }, `[Consumer ${consumerId}] State change`);
+    },
+    exchangeBindings
+  });
+  async function runConsumer() {
+    try {
+      logger.info({ consumerId }, `[Consumer ${consumerId}] Starting...`);
+      await consumer.connect();
+      logger.info({ consumerId }, `[Consumer ${consumerId}] Connected and listening for broadcasts`);
+      process.on("SIGINT", async () => {
+        logger.info({ consumerId }, `[Consumer ${consumerId}] Disconnecting...`);
+        await consumer.disconnect();
+        process.exit(0);
+      });
+      process.on("SIGTERM", async () => {
+        logger.info({ consumerId }, `[Consumer ${consumerId}] Disconnecting...`);
+        await consumer.disconnect();
+        process.exit(0);
+      });
+    } catch (error) {
+      logger.error({ error, consumerId }, `[Consumer ${consumerId}] Failed to start`);
+      process.exit(1);
+    }
+  }
+  runConsumer();
+} else {
+  logger.info("=== Starting 2 Broadcast Consumers Demo ===");
+  logger.info("Press Ctrl+C to stop all consumers");
+  logger.info("");
+  const consumers = [];
+  const consumer1 = spawn(process.execPath, [__filename], {
+    env: {
+      ...process.env,
+      IS_CHILD_CONSUMER: "true",
+      CONSUMER_ID: "1"
+    },
+    stdio: "inherit"
+  });
+  consumers.push(consumer1);
+  logger.info("\u2713 Consumer 1 launched");
+  const consumer2 = spawn(process.execPath, [__filename], {
+    env: {
+      ...process.env,
+      IS_CHILD_CONSUMER: "true",
+      CONSUMER_ID: "2"
+    },
+    stdio: "inherit"
+  });
+  consumers.push(consumer2);
+  logger.info("\u2713 Consumer 2 launched");
+  logger.info("");
+  logger.info("Both consumers are now listening for broadcast messages...");
+  process.on("SIGINT", () => {
+    logger.info("");
+    logger.info("Stopping all consumers...");
+    consumers.forEach((c) => c.kill("SIGINT"));
+    setTimeout(() => process.exit(0), 2e3);
+  });
+  process.on("SIGTERM", () => {
+    logger.info("Stopping all consumers...");
+    consumers.forEach((c) => c.kill("SIGTERM"));
+    setTimeout(() => process.exit(0), 2e3);
+  });
+  consumer1.on("exit", (code) => {
+    logger.info({ code }, "Consumer 1 exited");
+    if (code !== 0) {
+      logger.error("Consumer 1 exited with error, stopping all...");
+      consumers.forEach((c) => c.kill());
+      process.exit(1);
+    }
+  });
+  consumer2.on("exit", (code) => {
+    logger.info({ code }, "Consumer 2 exited");
+    if (code !== 0) {
+      logger.error("Consumer 2 exited with error, stopping all...");
+      consumers.forEach((c) => c.kill());
+      process.exit(1);
+    }
+  });
+}
+//# sourceMappingURL=broadcast-consumer.js.map