@palmetto/pubsub 1.0.7 → 1.1.0

package/dist/rabbitmq/config.d.ts

@@ -1,3 +1,4 @@
+import { AmqpConnectionManagerOptions } from "amqp-connection-manager";
 import { MessageContext, PubSubConfiguration } from "../interfaces.js";
 export interface RabbitMqConnectionConfig {
     /**
@@ -12,13 +13,13 @@ export interface RabbitMqConnectionConfig {
      * Timeout for publisher startup retries if the connection fails (default: 10 seconds)
      */
     startupRetryTimeoutMs?: number;
+    /**
+     * Override default amqp-connection-manager options (heartbeatIntervalInSeconds: 60, reconnectTimeInSeconds: 5)
+     */
+    options?: AmqpConnectionManagerOptions;
 }
 export type QueueType = "default" | "dead-letter" | "retry";
-export type ExchangeType = "direct" | "topic";
-/**
- * Default binding key for all messages
- */
-export declare const DEFAULT_BINDING_KEY = "default";
+export type ExchangeType = "direct" | "topic" | "fanout";
 export interface RabbitQueueExchangeConfiguration extends PubSubConfiguration {
     /**
      * The queue name prefix
@@ -29,11 +30,11 @@ export interface RabbitQueueExchangeConfiguration extends PubSubConfiguration {
      */
     topicSubscriberName?: string;
     /**
-     * Support direct exchange where each message is delivered once, or topic exchange where each message is delivered to multiple queues
+     * Support direct exchange where each message is delivered once, or topic/fanout exchange where each message is delivered to multiple queues
      */
-    exchangeType?: ExchangeType;
+    exchangeType: ExchangeType;
     /**
-     * When true, the queue and exchange will be deleted after the consumers exit [note: dead-letter exchanges & queues main remain when there are no dead-letter messages or consumers]
+     * When true, the queue and exchange will be deleted after the consumers exit [note: dead-letter exchanges & queues may remain when there are no dead-letter messages or consumers]
      */
     temporary?: boolean;
     /**
@@ -78,6 +79,7 @@ export interface RabbitMqMessageContext extends MessageContext {
  * @returns The queue name
  */
 export declare function getQueueName(config: RabbitQueueExchangeConfiguration): string;
+export declare const ExchangeNameExtensions: Record<QueueType, string | undefined>;
 export declare const QueueNameExtensions: Record<QueueType, string | undefined>;
 /**
  * Returns the exchange name based on the configuration

package/dist/rabbitmq/config.js

@@ -1,16 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueNameExtensions = exports.DEFAULT_BINDING_KEY = void 0;
+exports.QueueNameExtensions = exports.ExchangeNameExtensions = void 0;
 exports.getQueueName = getQueueName;
 exports.getExchangeName = getExchangeName;
 exports.getQueueType = getQueueType;
 exports.getRoutingKey = getRoutingKey;
 exports.getExchangeType = getExchangeType;
 const errors_js_1 = require("../errors.js");
-/**
- * Default binding key for all messages
- */
-exports.DEFAULT_BINDING_KEY = "default";
 /**
  * Returns the queue name based on the configuration
  *
@@ -24,25 +20,28 @@ function getQueueName(config) {
         return config.overrides.names[queueType].queueName;
     }
     let queueName = config.name;
-    if (config.exchangeType === "topic") {
+    if (config.exchangeType === "topic" || config.exchangeType === "fanout") {
         if (!config.topicSubscriberName) {
-            throw new errors_js_1.ConfigurationError("Topic queues must have a subscriber name");
+            throw new errors_js_1.ConfigurationError("Topic/Fanout queues must have a subscriber name");
         }
         queueName += "." + config.topicSubscriberName;
     }
-    if (queueType === "dead-letter") {
-        queueName += ".dlq";
-    }
-    else if (queueType === "retry") {
-        queueName += ".rtq";
+    const ext = exports.QueueNameExtensions[queueType];
+    if (ext) {
+        queueName += ext;
     }
     return queueName;
 }
-exports.QueueNameExtensions = {
+exports.ExchangeNameExtensions = {
     "dead-letter": ".dlx",
     retry: ".rtx",
     default: undefined,
 };
+exports.QueueNameExtensions = {
+    "dead-letter": ".dlq",
+    retry: ".rtq",
+    default: undefined,
+};
 /**
  * Returns the exchange name based on the configuration
  * @param config
@@ -56,14 +55,14 @@ function getExchangeName(config) {
     }
     let exchangeName = config.name;
     if (["dead-letter", "retry"].includes(queueType)) {
-        if (config.exchangeType === "topic") {
+        if (config.exchangeType === "topic" || config.exchangeType === "fanout") {
             if (!config.topicSubscriberName) {
                 throw new errors_js_1.ConfigurationError(`Topic ${queueType} exchanges must have a subscriber name`);
             }
             exchangeName += "." + config.topicSubscriberName;
         }
     }
-    const ext = exports.QueueNameExtensions[queueType];
+    const ext = exports.ExchangeNameExtensions[queueType];
     if (ext) {
         exchangeName += ext;
     }
@@ -74,9 +73,21 @@ function getQueueType(config) {
 }
 function getRoutingKey(config) {
     var _a, _b;
-    return (((_b = (_a = config.overrides) === null || _a === void 0 ? void 0 : _a.names[getQueueType(config)]) === null || _b === void 0 ? void 0 : _b.routingKey) ||
-        exports.DEFAULT_BINDING_KEY);
+    const queueType = getQueueType(config);
+    const configuredRoutingKey = (_b = (_a = config.overrides) === null || _a === void 0 ? void 0 : _a.names[queueType]) === null || _b === void 0 ? void 0 : _b.routingKey;
+    if (configuredRoutingKey) {
+        return configuredRoutingKey;
+    }
+    const exchangeType = getExchangeType(config);
+    switch (exchangeType) {
+        case "direct":
+            return "default";
+        case "topic":
+            return "#";
+        case "fanout":
+            return "";
+    }
 }
 function getExchangeType(config) {
-    return config.exchangeType || "direct";
+    return getQueueType(config) === "default" ? config.exchangeType : "fanout";
 }

package/dist/rabbitmq/connection.js

@@ -27,11 +27,15 @@ exports.RABBITMQ_TRANSPORT = "rabbitmq";
 class RabbitMqConnection {
     static create(config, logger) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const AmqpMgrPackage = yield (0, lazy_load_js_1.lazyLoad)({
                 packageName: "amqp-connection-manager",
                 context: "RabbitMqConnection",
             });
-            return new RabbitMqConnection(config, AmqpMgrPackage.connect(config.host), logger);
+            return new RabbitMqConnection(config, AmqpMgrPackage.connect(config.host, (_a = config.options) !== null && _a !== void 0 ? _a : {
+                heartbeatIntervalInSeconds: 60,
+                reconnectTimeInSeconds: 5,
+            }), logger);
         });
     }
     constructor(config, connection, logger) {
@@ -68,7 +72,7 @@ class RabbitMqConnection {
     }
     assertQueueAndBindings(channel, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            var _a, _b, _c;
             let dlConfig, retryConfig;
             ({ config, dlConfig, retryConfig } = RabbitMqConnection.getConfigs(config));
             const exchangeName = yield this.assertExchange(channel, config);
@@ -81,8 +85,8 @@ class RabbitMqConnection {
             // special case to ensure the retry dead-letter only reverts to the original queue,
             // regardless of original exchange type [that is, not re-using the original queue exchange here]
             const retryDlExchangeName = ((_a = config.overrides) === null || _a === void 0 ? void 0 : _a.retryQueueExchangeName) ||
-                `${queueName}${config_js_1.QueueNameExtensions["dead-letter"]}${config_js_1.QueueNameExtensions["retry"]}`;
-            yield channel.assertExchange(retryDlExchangeName, "direct", {
+                `${queueName}${config_js_1.QueueNameExtensions["retry"]}${config_js_1.ExchangeNameExtensions["dead-letter"]}`;
+            yield channel.assertExchange(retryDlExchangeName, "fanout", {
                 autoDelete: !!config.temporary,
             });
             (_c = (_b = this.logger).debug) === null || _c === void 0 ? void 0 : _c.call(_b, `Asserted exchange ${retryDlExchangeName}`);
@@ -93,13 +97,13 @@ class RabbitMqConnection {
             // create the default queue using the dead-letter exchange as the DLX
             yield this.assertQueue(channel, queueName, autoDelete, dlExchangeName);
             // bind the default queue using the default exchange and default routing key
-            yield this.bindQueue(channel, queueName, exchangeName, ((_e = (_d = config.overrides) === null || _d === void 0 ? void 0 : _d.names.default) === null || _e === void 0 ? void 0 : _e.routingKey) || config_js_1.DEFAULT_BINDING_KEY);
-            // bind the dead-letter queue to the dead-letter exchange and dead-letter routing key
-            yield this.bindQueue(channel, dlQueueName, dlExchangeName, ((_g = (_f = config.overrides) === null || _f === void 0 ? void 0 : _f.names["dead-letter"]) === null || _g === void 0 ? void 0 : _g.routingKey) || config_js_1.DEFAULT_BINDING_KEY);
-            // bind the retry queue to the retry exchange and retry routing key
-            yield this.bindQueue(channel, retryQueueName, retryExchangeName, ((_j = (_h = config.overrides) === null || _h === void 0 ? void 0 : _h.names.retry) === null || _j === void 0 ? void 0 : _j.routingKey) || config_js_1.DEFAULT_BINDING_KEY);
-            // bind the queue to the retry dead-letter exchange and default routing key
-            yield this.bindQueue(channel, queueName, retryDlExchangeName, ((_l = (_k = config.overrides) === null || _k === void 0 ? void 0 : _k.names.default) === null || _l === void 0 ? void 0 : _l.routingKey) || config_js_1.DEFAULT_BINDING_KEY);
+            yield this.bindQueue(channel, queueName, exchangeName, (0, config_js_1.getRoutingKey)(config));
+            // bind the dead-letter queue to the dead-letter exchange
+            yield this.bindQueue(channel, dlQueueName, dlExchangeName, "");
+            // bind the retry queue to the retry exchange
+            yield this.bindQueue(channel, retryQueueName, retryExchangeName, "");
+            // bind the queue to the retry dead-letter exchange
+            yield this.bindQueue(channel, queueName, retryDlExchangeName, "");
             return {
                 exchangeName,
                 dlExchangeName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palmetto/pubsub",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "main": "./dist/main.js",
   "scripts": {
     "lint": "yarn run -T eslint --fix ./src",

package/src/rabbitmq/README.md

@@ -125,26 +125,37 @@ const config: RabbitQueueExchangeConfiguration = {
   name: "my.queue",
   transport: RABBITMQ_TRANSPORT,
   schema: MyModelSchema,
+  exchangeType: "direct",
 };
 ```
 
 This configuration creates the following queues:
 
 - `my.queue` the main queue which receives all messages published using the config
-  - dead-letter-exchange is set to `my.queue.dlx`
+  - `x-dead-letter-exchange` is set to `my.queue.dlx`
 - `my.queue.dlq` the main queue's dead-letter queue where failed messages end up
+  - bound to `my.queue.dlx` exchange
 - `my.queue.rtq` the main queue's retry queue where messages to be retried end up
-  - dead-letter-exchange is set to the main queue's exchange so that messages are retried
+  - bound to `my.queue.rtx` exchange
+  - `x-dead-letter-exchange` is set to `my.queue.rtq.dlx`
+  - messages delivered here have an expiration
+  - when the message expires, it is removed from the queue and sent to the `my.queue.rtq.dlx` exchange which publishes the message back to the main queue `my.queue`
 
-And these direct exchanges:
+And these exchanges:
 
 - `my.queue` the main exchange that is bound to the main queue
-- `my.queue.dlx` the dead-letter exchange that receives failed messages from the main queue
-- `my.queue.rtx` the retry exchange that receives messages to retry. it is bound to the retry queue
-
-### Topic exchanges
-
-Topic exchanges provide the ability to use a single exchange to copy messages to multiple queues simultaneously. When subscribing to a topic exchange, you must also provide a subscriber name to include in the queue name. This ensures that there is a unique queue for each subscriber of the exchange.
+- `my.queue.dlx` a fanout dead-letter exchange that receives failed messages from the main queue
+  - binding made to the `my.queue.dlq`
+  - configured as the `x-dead-letter-exchange` for the main queue `my.queue`
+- `my.queue.rtx` a fanout retry exchange that receives messages to retry. it is bound to the retry queue
+  - binding made to the `my.queue.rtq`
+- `my.queue.rtq.dlx` a fanout dead-letter exchange that receives retry messages from the retry queue
+  - binding made back to the original `my.queue`
+  - configured as the `x-dead-letter-exchange` for the retry queue `my.queue.rtq`
+
+### Topic/Fanout exchanges
+
+Topic/Fanout exchanges provide the ability to use a single exchange to copy messages to multiple queues simultaneously. When subscribing to a topic exchange, you must also provide a subscriber name to include in the queue name. This ensures that there is a unique queue for each subscriber of the exchange.
 
 ```ts
 const config: RabbitQueueExchangeConfiguration = {