@palmetto/pubsub 1.0.0

package/dist/interfaces.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageResult = exports.IdMetaSchema = exports.MetaSchema = void 0;
+const v4_1 = require("zod/v4");
+exports.MetaSchema = v4_1.z.object({
+    createdAt: v4_1.z.iso.datetime(),
+    schemaId: v4_1.z.string(),
+    publishedBy: v4_1.z.string(),
+});
+exports.IdMetaSchema = v4_1.z.object({
+    id: v4_1.z.string().optional(),
+    meta: exports.MetaSchema.optional(),
+});
+var MessageResult;
+(function (MessageResult) {
+    /**
+     * the message was handled successfully or can otherwise be ignored
+     */
+    MessageResult["Ok"] = "ok";
+    /**
+     * The message should be retried
+     */
+    MessageResult["Retry"] = "retry";
+    /**
+     * The message failed and is either discarded or stored in a dead-letter queue
+     */
+    MessageResult["Fail"] = "fail";
+})(MessageResult || (exports.MessageResult = MessageResult = {}));

package/dist/lazy-load.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This loads and returns a typed package.
+ * TPackage is a package type
+ * @returns The package
+ */
+export declare function lazyLoad<TPackage>({ packageName, context, }: {
+    /** The name of the package to load (eg: "bullmq") */
+    packageName: string;
+    /** The name of the module trying to lazy-load the package (eg: "BullMqPublisher")   */
+    context: string;
+}): Promise<TPackage>;

package/dist/lazy-load.js

@@ -0,0 +1,79 @@
+"use strict";
+/*
+   example usage:
+ 
+   // this imports the package as a type:
+   import type * as bullmq from "bullmq";
+  
+   //then call lazyLoad with a function that is called at runtime, not a static startup call:
+    const BullMqPackage = await lazyLoad<
+        typeof bullmq,
+    >({
+        packageName: "bullmq",
+        context: "BullMqPublisher",
+    });
+
+    // then you can use the result of lazyLoad as if it was the original imported package type:
+    const queue = new BullMqPackage.Queue(new BullMqPackage.Queue(queueName, {
+      connection: this.connection,
+    });
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyLoad = lazyLoad;
+/**
+ * This loads and returns a typed package.
+ * TPackage is a package type
+ * @returns The package
+ */
+function lazyLoad(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ packageName, context, }) {
+        try {
+            return (yield Promise.resolve(`${packageName}`).then(s => __importStar(require(s))));
+        }
+        catch (err) {
+            throw new Error(`The "${packageName}" package is missing. Please, make sure to install it to take advantage of ${context}.`, { cause: err });
+        }
+    });
+}

package/dist/main.d.ts

@@ -0,0 +1,6 @@
+export * from "./errors.js";
+export * from "./interfaces.js";
+export * from "./publisher.js";
+export * from "./subscriber.js";
+export * from "./bullmq/main.js";
+export * from "./rabbitmq/main.js";

package/dist/main.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./interfaces.js"), exports);
+__exportStar(require("./publisher.js"), exports);
+__exportStar(require("./subscriber.js"), exports);
+__exportStar(require("./bullmq/main.js"), exports);
+__exportStar(require("./rabbitmq/main.js"), exports);

package/dist/publisher.d.ts

@@ -0,0 +1,11 @@
+import { BaseMessage, Logger, PublisherProvider, PubSubConfiguration } from "./interfaces";
+export declare class Publisher {
+    private readonly logger;
+    private readonly hashes;
+    private readonly publisherProviders;
+    constructor(logger: Logger, providers?: PublisherProvider[]);
+    addProvider(provider: PublisherProvider): void;
+    removeProvider(providerOrTransport: PublisherProvider | string): boolean;
+    publish(config: PubSubConfiguration, message: BaseMessage): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/publisher.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Publisher = void 0;
+const v4_1 = require("zod/v4");
+const uuid_1 = require("uuid");
+const crypto_hash_1 = require("crypto-hash");
+const errors_1 = require("./errors");
+class Publisher {
+    constructor(logger, providers) {
+        this.logger = logger;
+        this.hashes = new Map();
+        this.publisherProviders = new Map();
+        if (providers) {
+            providers.forEach((provider) => this.publisherProviders.set(provider.transport, provider));
+        }
+    }
+    addProvider(provider) {
+        var _a, _b;
+        this.publisherProviders.set(provider.transport, provider);
+        (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Publisher added provider for ${provider.transport}`);
+    }
+    removeProvider(providerOrTransport) {
+        var _a, _b;
+        let transport;
+        if (typeof providerOrTransport === "string") {
+            transport = providerOrTransport;
+        }
+        else {
+            transport = providerOrTransport.transport;
+        }
+        (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Publisher removing provider for ${transport}`);
+        return this.publisherProviders.delete(transport);
+    }
+    publish(config, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { transport, schema } = config;
+            const provider = this.publisherProviders.get(transport);
+            if (!provider) {
+                throw new errors_1.MissingPubSubProviderError(`No provider configured for ${transport}`);
+            }
+            if (!message.id) {
+                message.id = (0, uuid_1.v4)();
+            }
+            let hash = this.hashes.get(schema);
+            if (!hash) {
+                const jsonSchema = JSON.stringify(v4_1.z.toJSONSchema(schema), null, 3);
+                hash = yield (0, crypto_hash_1.sha256)(jsonSchema);
+                this.hashes.set(schema, hash);
+            }
+            if (!message.meta) {
+                message.meta = {
+                    createdAt: new Date().toISOString(),
+                    publishedBy: "",
+                    schemaId: hash,
+                };
+            }
+            else {
+                message.meta.schemaId = hash;
+            }
+            const json = JSON.stringify(message);
+            const check = schema.safeParse(JSON.parse(json));
+            if (!check.success) {
+                throw new errors_1.SchemaValidationError(`Schema did not accept the published message: ${check.error.message}`);
+            }
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Publisher publishing message for ${transport}`);
+            yield provider.publish(config, json);
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const provider of this.publisherProviders.values()) {
+                yield provider.close();
+            }
+        });
+    }
+}
+exports.Publisher = Publisher;

package/dist/rabbitmq/config.d.ts

@@ -0,0 +1,84 @@
+import { MessageContext, PubSubConfiguration } from "../interfaces";
+export interface RabbitMqConnectionConfig {
+    /**
+     * The URL to the RabbitMQ host
+     */
+    host: string;
+    /**
+     * Delay between publisher startup retries if the connection fails (default: 500ms)
+     */
+    startupRetryDelayMs?: number;
+    /**
+     * Timeout for publisher startup retries if the connection fails (default: 10 seconds)
+     */
+    startupRetryTimeoutMs?: number;
+}
+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 interface RabbitQueueExchangeConfiguration extends PubSubConfiguration {
+    /**
+     * The queue name prefix
+     */
+    name: string;
+    /**
+     * For topic exchanges, the name of the subscriber is used here
+     */
+    topicSubscriberName?: string;
+    /**
+     * Support direct exchange where each message is delivered once, or topic exchange where each message is delivered to multiple queues
+     */
+    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]
+     */
+    temporary?: boolean;
+    /**
+     * The queue prefetch amount for subscribers. Defaults to 5 if not set.
+     */
+    prefetch?: number;
+    /**
+     * Pass a queueType when you want to publish or subscribe to the dead-letter or retry queues.
+     */
+    queueType?: QueueType;
+    /**
+     * Override default queue & exchange names
+     */
+    overrides?: RabbitQueueExchangeCustomConfiguration;
+}
+export interface RabbitQueueExchangeNames {
+    queueName?: string;
+    exchangeName?: string;
+    routingKey?: string;
+}
+/**
+ * A collection of properties to override default pub/sub configuration values
+ */
+export interface RabbitQueueExchangeCustomConfiguration {
+    names: Partial<Record<QueueType, RabbitQueueExchangeNames>>;
+    retryQueueExchangeName?: string;
+}
+export interface RabbitMqMessageContext extends MessageContext {
+    exchangeName?: string;
+    routingKey?: string;
+}
+/**
+ * Returns the queue name based on the configuration
+ *
+ * @param config
+ * @returns The queue name
+ */
+export declare function getQueueName(config: RabbitQueueExchangeConfiguration): string;
+export declare const QueueNameExtensions: Record<QueueType, string | undefined>;
+/**
+ * Returns the exchange name based on the configuration
+ * @param config
+ * @returns The exchange name
+ */
+export declare function getExchangeName(config: RabbitQueueExchangeConfiguration): string;
+export declare function getQueueType(config: RabbitQueueExchangeConfiguration): QueueType;
+export declare function getRoutingKey(config: RabbitQueueExchangeConfiguration): string;
+export declare function getExchangeType(config: RabbitQueueExchangeConfiguration): ExchangeType;

package/dist/rabbitmq/config.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueNameExtensions = exports.DEFAULT_BINDING_KEY = void 0;
+exports.getQueueName = getQueueName;
+exports.getExchangeName = getExchangeName;
+exports.getQueueType = getQueueType;
+exports.getRoutingKey = getRoutingKey;
+exports.getExchangeType = getExchangeType;
+const errors_1 = require("../errors");
+/**
+ * Default binding key for all messages
+ */
+exports.DEFAULT_BINDING_KEY = "default";
+/**
+ * Returns the queue name based on the configuration
+ *
+ * @param config
+ * @returns The queue name
+ */
+function getQueueName(config) {
+    var _a, _b;
+    const queueType = getQueueType(config);
+    if ((_b = (_a = config.overrides) === null || _a === void 0 ? void 0 : _a.names[queueType]) === null || _b === void 0 ? void 0 : _b.queueName) {
+        return config.overrides.names[queueType].queueName;
+    }
+    let queueName = config.name;
+    if (config.exchangeType === "topic") {
+        if (!config.topicSubscriberName) {
+            throw new errors_1.ConfigurationError("Topic queues must have a subscriber name");
+        }
+        queueName += "." + config.topicSubscriberName;
+    }
+    if (queueType === "dead-letter") {
+        queueName += ".dlq";
+    }
+    else if (queueType === "retry") {
+        queueName += ".rtq";
+    }
+    return queueName;
+}
+exports.QueueNameExtensions = {
+    "dead-letter": ".dlx",
+    retry: ".rtx",
+    default: undefined,
+};
+/**
+ * Returns the exchange name based on the configuration
+ * @param config
+ * @returns The exchange name
+ */
+function getExchangeName(config) {
+    var _a, _b;
+    const queueType = getQueueType(config);
+    if ((_b = (_a = config.overrides) === null || _a === void 0 ? void 0 : _a.names[queueType]) === null || _b === void 0 ? void 0 : _b.exchangeName) {
+        return config.overrides.names[queueType].exchangeName;
+    }
+    let exchangeName = config.name;
+    if (["dead-letter", "retry"].includes(queueType)) {
+        if (config.exchangeType === "topic") {
+            if (!config.topicSubscriberName) {
+                throw new errors_1.ConfigurationError(`Topic ${queueType} exchanges must have a subscriber name`);
+            }
+            exchangeName += "." + config.topicSubscriberName;
+        }
+    }
+    const ext = exports.QueueNameExtensions[queueType];
+    if (ext) {
+        exchangeName += ext;
+    }
+    return exchangeName;
+}
+function getQueueType(config) {
+    return config.queueType || "default";
+}
+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);
+}
+function getExchangeType(config) {
+    return config.exchangeType || "direct";
+}

package/dist/rabbitmq/connection.d.ts

@@ -0,0 +1,41 @@
+import type * as amqpmgr from "amqp-connection-manager";
+import type { Channel } from "amqplib";
+import { RabbitQueueExchangeConfiguration, RabbitMqConnectionConfig } from "./config";
+import { Logger } from "../interfaces";
+export declare class SocketError extends Error {
+    readonly code: string;
+    readonly error: unknown;
+    constructor(code: string, error: unknown);
+}
+export declare const RABBITMQ_TRANSPORT = "rabbitmq";
+/**
+ * Manages access to the AMQP connection itself
+ */
+export declare class RabbitMqConnection {
+    readonly connection: amqpmgr.AmqpConnectionManager;
+    private readonly logger;
+    readonly config: RabbitMqConnectionConfig;
+    static create(config: RabbitMqConnectionConfig, logger: Logger): Promise<RabbitMqConnection>;
+    private constructor();
+    close(): Promise<void>;
+    /**
+     * Creates the exchanges necessary for the given config
+     * @param channel
+     * @param config Must be isDlq === false | undefined
+     * @param dlConfig Must be isDlq
+     * @returns
+     */
+    assertExchange(channel: Channel, config: RabbitQueueExchangeConfiguration): Promise<string>;
+    assertQueueAndBindings(channel: Channel, config: RabbitQueueExchangeConfiguration): Promise<{
+        exchangeName: string;
+        dlExchangeName: string;
+        retryExchangeName: string;
+        queueName: string;
+        dlQueueName: string;
+        retryQueueName: string;
+        retryDlExchangeName: string;
+    }>;
+    private assertQueue;
+    private bindQueue;
+    private static getConfigs;
+}

package/dist/rabbitmq/connection.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMqConnection = exports.RABBITMQ_TRANSPORT = exports.SocketError = void 0;
+const config_1 = require("./config");
+const lazy_load_1 = require("../lazy-load");
+class SocketError extends Error {
+    constructor(code, error) {
+        super(`Socket error: ${code}`);
+        this.code = code;
+        this.error = error;
+    }
+}
+exports.SocketError = SocketError;
+exports.RABBITMQ_TRANSPORT = "rabbitmq";
+/**
+ * Manages access to the AMQP connection itself
+ */
+class RabbitMqConnection {
+    static create(config, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const AmqpMgrPackage = yield (0, lazy_load_1.lazyLoad)({
+                packageName: "amqp-connection-manager",
+                context: "RabbitMqConnection",
+            });
+            return new RabbitMqConnection(config, AmqpMgrPackage.connect(config.host), logger);
+        });
+    }
+    constructor(config, connection, logger) {
+        this.connection = connection;
+        this.logger = logger;
+        this.config = Object.assign({}, config);
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, "RabbitMQ closing connection");
+            yield this.connection.close();
+        });
+    }
+    /**
+     * Creates the exchanges necessary for the given config
+     * @param channel
+     * @param config Must be isDlq === false | undefined
+     * @param dlConfig Must be isDlq
+     * @returns
+     */
+    assertExchange(channel, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { exchange } = yield channel.assertExchange((0, config_1.getExchangeName)(config), (0, config_1.getExchangeType)(config), {
+                autoDelete: !!config.temporary,
+            });
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Asserted exchange ${exchange}`);
+            return exchange;
+        });
+    }
+    assertQueueAndBindings(channel, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            let dlConfig, retryConfig;
+            ({ config, dlConfig, retryConfig } = RabbitMqConnection.getConfigs(config));
+            const exchangeName = yield this.assertExchange(channel, config);
+            const dlExchangeName = yield this.assertExchange(channel, dlConfig);
+            const retryExchangeName = yield this.assertExchange(channel, retryConfig);
+            const queueName = (0, config_1.getQueueName)(config);
+            const dlQueueName = (0, config_1.getQueueName)(dlConfig);
+            const retryQueueName = (0, config_1.getQueueName)(retryConfig);
+            const autoDelete = !!config.temporary;
+            // 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_1.QueueNameExtensions["dead-letter"]}${config_1.QueueNameExtensions["retry"]}`;
+            yield channel.assertExchange(retryDlExchangeName, "direct", {
+                autoDelete: !!config.temporary,
+            });
+            (_c = (_b = this.logger).debug) === null || _c === void 0 ? void 0 : _c.call(_b, `Asserted exchange ${retryDlExchangeName}`);
+            // create the dead-letter queue without any DLX
+            yield this.assertQueue(channel, dlQueueName, autoDelete);
+            // create the retry queue using retry dead-letter exchange as the DLX
+            yield this.assertQueue(channel, retryQueueName, autoDelete, retryDlExchangeName);
+            // 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_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_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_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_1.DEFAULT_BINDING_KEY);
+            return {
+                exchangeName,
+                dlExchangeName,
+                retryExchangeName,
+                queueName,
+                dlQueueName,
+                retryQueueName,
+                retryDlExchangeName,
+            };
+        });
+    }
+    assertQueue(channel, queueName, autoDelete, deadLetterExchange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            yield channel.assertQueue(queueName, {
+                autoDelete,
+                deadLetterExchange,
+            });
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Asserted queue ${queueName}`);
+        });
+    }
+    bindQueue(channel, queueName, exchangeName, bindingKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            yield channel.bindQueue(queueName, exchangeName, bindingKey);
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Bound queue ${queueName} to ${exchangeName}:${bindingKey}`);
+        });
+    }
+    static getConfigs(config) {
+        const dlConfig = config.queueType === "dead-letter"
+            ? config
+            : Object.assign(Object.assign({}, config), { queueType: "dead-letter" });
+        const retryConfig = config.queueType === "retry" ? config : Object.assign(Object.assign({}, config), { queueType: "retry" });
+        config =
+            !config.queueType || config.queueType === "default"
+                ? config
+                : Object.assign(Object.assign({}, config), { queueType: "default" });
+        return { config, dlConfig, retryConfig };
+    }
+}
+exports.RabbitMqConnection = RabbitMqConnection;

package/dist/rabbitmq/main.d.ts

@@ -0,0 +1,5 @@
+export * from "./config.js";
+export * from "./connection.js";
+export * from "./publisher.js";
+export * from "./subscriber.js";
+export * from "./pubsub.js";

package/dist/rabbitmq/main.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config.js"), exports);
+__exportStar(require("./connection.js"), exports);
+__exportStar(require("./publisher.js"), exports);
+__exportStar(require("./subscriber.js"), exports);
+__exportStar(require("./pubsub.js"), exports);

package/dist/rabbitmq/publisher.d.ts

@@ -0,0 +1,29 @@
+import type { ChannelWrapper } from "amqp-connection-manager";
+import { Logger, PublisherProvider } from "../interfaces";
+import { RabbitMqConnection } from "./connection";
+import { RabbitQueueExchangeConfiguration } from "./config";
+export declare class RabbitMqPublisher implements PublisherProvider {
+    private readonly connection;
+    private readonly logger;
+    private inited;
+    private channel?;
+    private connected;
+    constructor(connection: RabbitMqConnection, logger: Logger);
+    readonly transport: string;
+    /**
+     * Initializes the rabbit connection and asserts the exchange for the configuration.
+     *
+     * @param config
+     * @returns a Promise containing the ChannelWrapper to publish messages with
+     */
+    init(config: RabbitQueueExchangeConfiguration): Promise<ChannelWrapper>;
+    /**
+     * Publishes a message to Rabbit based on the configuration
+     *
+     * @param config The rabbit queue configuration
+     * @param message The JSON message to send
+     * @returns A promise that is completed when the message is published
+     */
+    publish(config: RabbitQueueExchangeConfiguration, message: string): Promise<void>;
+    close(): Promise<void> | undefined;
+}