@palmetto/pubsub 1.0.0

package/dist/rabbitmq/publisher.js

@@ -0,0 +1,98 @@
+"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.RabbitMqPublisher = void 0;
+const errors_1 = require("../errors");
+const connection_1 = require("./connection");
+const config_1 = require("./config");
+const utility_1 = require("./utility");
+class RabbitMqPublisher {
+    constructor(connection, logger) {
+        this.connection = connection;
+        this.logger = logger;
+        this.inited = new Set();
+        this.connected = false;
+        this.transport = connection_1.RABBITMQ_TRANSPORT;
+    }
+    /**
+     * 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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const delayMs = this.connection.config.startupRetryDelayMs || 500;
+            const timeoutMs = this.connection.config.startupRetryTimeoutMs || 20000;
+            const timeoutAfter = new Date(new Date().getTime() + timeoutMs);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            while (true) {
+                try {
+                    if (!this.channel) {
+                        this.channel = this.connection.connection.createChannel({
+                            confirm: true,
+                            json: false,
+                        });
+                        (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, "RabbitMq created confirm channel for publisher");
+                    }
+                    if (!this.connected) {
+                        yield this.channel.waitForConnect();
+                        this.connected = true;
+                    }
+                    if (!this.inited.has(config)) {
+                        yield this.channel.addSetup((channel) => __awaiter(this, void 0, void 0, function* () {
+                            yield this.connection.assertExchange(channel, config);
+                        }));
+                        (_d = (_c = this.logger).debug) === null || _d === void 0 ? void 0 : _d.call(_c, `RabbitMq created setup for publisher for ${(0, config_1.getExchangeName)(config)}`);
+                        this.inited.add(config);
+                    }
+                    return this.channel;
+                }
+                catch (err) {
+                    if (new Date() >= timeoutAfter) {
+                        throw err;
+                    }
+                    yield (0, utility_1.delay)(delayMs);
+                }
+            }
+        });
+    }
+    /**
+     * 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, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const channel = yield this.init(config);
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Publishing message to ${(0, config_1.getExchangeName)(config)} - ${message} [starting]`);
+            const exchangeName = (0, config_1.getExchangeName)(config);
+            const ok = yield channel.publish(exchangeName, (0, config_1.getRoutingKey)(config), Buffer.from(message, "utf8"), {
+                contentType: "application/json",
+                timestamp: new Date().valueOf(),
+                persistent: true,
+            });
+            (_d = (_c = this.logger).debug) === null || _d === void 0 ? void 0 : _d.call(_c, `Published message to ${(0, config_1.getExchangeName)(config)} - ${message} [${ok}]`);
+            if (!ok) {
+                throw new errors_1.PublishError(`RabbitMq publish to ${exchangeName} failed`);
+            }
+        });
+    }
+    close() {
+        var _a;
+        return (_a = this.channel) === null || _a === void 0 ? void 0 : _a.close();
+    }
+}
+exports.RabbitMqPublisher = RabbitMqPublisher;

package/dist/rabbitmq/pubsub.d.ts

@@ -0,0 +1,15 @@
+import { Logger, MessageContext, MessageResult, PubSubProvider, StopSubscribe } from "../interfaces";
+import { RabbitQueueExchangeConfiguration } from "./config";
+import { RabbitMqConnection } from "./connection";
+/**
+ * Combines a RabbitMqPublisher and RabbitMqSubscriber into a single instance
+ */
+export declare class RabbitMqPubSubProvider implements PubSubProvider {
+    private readonly publisher;
+    private readonly subscriber;
+    constructor(connection: RabbitMqConnection, logger: Logger);
+    readonly transport: string;
+    publish(config: RabbitQueueExchangeConfiguration, message: string): Promise<void>;
+    startSubscribe(config: RabbitQueueExchangeConfiguration, onMessage: (s: string, context: MessageContext) => Promise<MessageResult> | MessageResult): StopSubscribe;
+    close(): Promise<void>;
+}

package/dist/rabbitmq/pubsub.js

@@ -0,0 +1,37 @@
+"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.RabbitMqPubSubProvider = void 0;
+const connection_1 = require("./connection");
+const publisher_1 = require("./publisher");
+const subscriber_1 = require("./subscriber");
+/**
+ * Combines a RabbitMqPublisher and RabbitMqSubscriber into a single instance
+ */
+class RabbitMqPubSubProvider {
+    constructor(connection, logger) {
+        this.transport = connection_1.RABBITMQ_TRANSPORT;
+        this.publisher = new publisher_1.RabbitMqPublisher(connection, logger);
+        this.subscriber = new subscriber_1.RabbitMqSubscriber(connection, logger);
+    }
+    publish(config, message) {
+        return this.publisher.publish(config, message);
+    }
+    startSubscribe(config, onMessage) {
+        return this.subscriber.startSubscribe(config, onMessage);
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([this.subscriber.close(), this.publisher.close()]);
+        });
+    }
+}
+exports.RabbitMqPubSubProvider = RabbitMqPubSubProvider;

package/dist/rabbitmq/subscriber.d.ts

@@ -0,0 +1,33 @@
+import type { ConsumeMessage } from "amqplib";
+import type { ChannelWrapper } from "amqp-connection-manager";
+import { Logger, MessageResult, StopSubscribe, SubscriberProvider } from "../interfaces";
+import { RabbitMqMessageContext, RabbitQueueExchangeConfiguration } from "./config";
+import { RabbitMqConnection } from "./connection";
+declare class SubscribedMessage {
+    private readonly owner;
+    private readonly logger;
+    readonly config: RabbitQueueExchangeConfiguration;
+    readonly onMessage: (s: string, context: RabbitMqMessageContext) => Promise<MessageResult> | MessageResult;
+    stop?: StopSubscribe | undefined;
+    channel?: ChannelWrapper;
+    busy: number;
+    constructor(owner: RabbitMqSubscriber, logger: Logger, config: RabbitQueueExchangeConfiguration, onMessage: (s: string, context: RabbitMqMessageContext) => Promise<MessageResult> | MessageResult, stop?: StopSubscribe | undefined);
+    stopSubscribe(): Promise<void>;
+}
+export declare class RabbitMqSubscriber implements SubscriberProvider {
+    private readonly connection;
+    private readonly logger;
+    private readonly subscribers;
+    constructor(connection: RabbitMqConnection, logger: Logger);
+    readonly transport: string;
+    removeSubscriber(subscribedMessage: SubscribedMessage): void;
+    startSubscribe(config: RabbitQueueExchangeConfiguration, onMessage: (s: string, context: RabbitMqMessageContext) => Promise<MessageResult> | MessageResult): StopSubscribe;
+    close(): Promise<void>;
+    static getRetries(msg: ConsumeMessage): number;
+    static getSentDates(msg: ConsumeMessage): {
+        firstSent: Date | undefined;
+        lastSent: Date | undefined;
+    };
+    private actuallySubscribe;
+}
+export {};

package/dist/rabbitmq/subscriber.js

@@ -0,0 +1,197 @@
+"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.RabbitMqSubscriber = void 0;
+const interfaces_1 = require("../interfaces");
+const errors_1 = require("../errors");
+const config_1 = require("./config");
+const connection_1 = require("./connection");
+class SubscribedMessage {
+    constructor(owner, logger, config, onMessage, stop) {
+        this.owner = owner;
+        this.logger = logger;
+        this.config = config;
+        this.onMessage = onMessage;
+        this.stop = stop;
+        this.busy = 0;
+    }
+    stopSubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (this.stop) {
+                // avoid re-entry by swapping this.stop
+                const s = this.stop;
+                this.stop = undefined;
+                this.owner.removeSubscriber(this);
+                if (this.busy) {
+                    (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, "RabbitMq subscriber waiting for handler to finish");
+                    const start = new Date().valueOf();
+                    const waitDelay = 5;
+                    let busyCheck = 1000 / waitDelay; // wait up to a second or so
+                    while (this.busy && busyCheck > 0) {
+                        yield new Promise((resolve) => setTimeout(resolve, waitDelay));
+                        busyCheck -= waitDelay;
+                    }
+                    const delay = new Date().valueOf() - start;
+                    (_d = (_c = this.logger).debug) === null || _d === void 0 ? void 0 : _d.call(_c, `RabbitMq subscriber waited ${delay}ms for handler to finish`);
+                }
+                yield s();
+            }
+        });
+    }
+}
+const RETRIES_HEADER = "x-retries";
+const RETRYSENT_HEADER = "x-retry-sent";
+class RabbitMqSubscriber {
+    constructor(connection, logger) {
+        this.connection = connection;
+        this.logger = logger;
+        this.subscribers = new Map();
+        this.transport = connection_1.RABBITMQ_TRANSPORT;
+    }
+    removeSubscriber(subscribedMessage) {
+        for (const [key, value] of this.subscribers) {
+            if (value === subscribedMessage) {
+                this.subscribers.delete(key);
+                break;
+            }
+        }
+    }
+    startSubscribe(config, onMessage) {
+        const queueName = (0, config_1.getQueueName)(config);
+        let subscribedMessage = this.subscribers.get(queueName);
+        if (subscribedMessage) {
+            throw new errors_1.AlreadySubscribingError(queueName);
+        }
+        subscribedMessage = new SubscribedMessage(this, this.logger, config, onMessage);
+        this.subscribers.set(queueName, subscribedMessage);
+        subscribedMessage.channel = this.connection.connection.createChannel({
+            setup: (channel) => __awaiter(this, void 0, void 0, function* () {
+                yield this.actuallySubscribe(channel, subscribedMessage);
+            }),
+        });
+        return () => subscribedMessage.stopSubscribe();
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const subscribedMessage of this.subscribers.values()) {
+                yield subscribedMessage.stopSubscribe();
+            }
+            this.subscribers.clear();
+        });
+    }
+    static getRetries(msg) {
+        var _a;
+        return typeof ((_a = msg.properties.headers) === null || _a === void 0 ? void 0 : _a[RETRIES_HEADER]) === "number"
+            ? msg.properties.headers[RETRIES_HEADER]
+            : msg.fields.redelivered
+                ? 1
+                : 0;
+    }
+    static getSentDates(msg) {
+        var _a;
+        const firstSent = typeof msg.properties.timestamp === "number"
+            ? new Date(msg.properties.timestamp)
+            : undefined;
+        const lastSent = typeof ((_a = msg.properties.headers) === null || _a === void 0 ? void 0 : _a[RETRYSENT_HEADER]) === "number"
+            ? new Date(msg.properties.headers[RETRYSENT_HEADER])
+            : firstSent;
+        return { firstSent, lastSent };
+    }
+    actuallySubscribe(channel, subscribedMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const retryDelay = subscribedMessage.config.retryDelay || 30000; // default 30 second retry delay
+            const onRabbitMessage = (msg) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                const json = msg.content.toString("utf8");
+                const retries = RabbitMqSubscriber.getRetries(msg);
+                const sentDates = RabbitMqSubscriber.getSentDates(msg);
+                const context = Object.assign(Object.assign({ retries }, sentDates), { exchangeName: msg.fields.exchange, routingKey: msg.fields.routingKey });
+                let messageResult;
+                try {
+                    messageResult = yield subscribedMessage.onMessage(json, context);
+                }
+                catch (err) {
+                    messageResult = interfaces_1.MessageResult.Retry;
+                    this.logger.error(`RabbitMq consumer unhandled exception, retrying message to ${retryExchangeName} ${msg.fields.routingKey}`, err);
+                }
+                if (messageResult === interfaces_1.MessageResult.Ok) {
+                    channel.ack(msg);
+                    return;
+                }
+                if (messageResult === interfaces_1.MessageResult.Retry &&
+                    subscribedMessage.config.retries &&
+                    retries >= subscribedMessage.config.retries) {
+                    messageResult = interfaces_1.MessageResult.Fail;
+                }
+                if (messageResult === interfaces_1.MessageResult.Fail) {
+                    (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `RabbitMq retry count exceeded - sending message to DLQ`);
+                    channel.nack(msg, undefined, false);
+                    return;
+                }
+                const ok = yield ((_c = subscribedMessage.channel) === null || _c === void 0 ? void 0 : _c.publish(retryExchangeName, msg.fields.routingKey, msg.content, {
+                    contentType: msg.properties.contentType,
+                    expiration: retryDelay,
+                    timestamp: (_d = sentDates.firstSent) === null || _d === void 0 ? void 0 : _d.valueOf(),
+                    headers: {
+                        [RETRIES_HEADER]: retries + 1,
+                        [RETRYSENT_HEADER]: new Date().valueOf(),
+                    },
+                }));
+                if (ok) {
+                    (_f = (_e = this.logger).debug) === null || _f === void 0 ? void 0 : _f.call(_e, `RabbitMq retry queue success`);
+                    channel.ack(msg);
+                }
+                else {
+                    (_h = (_g = this.logger).debug) === null || _h === void 0 ? void 0 : _h.call(_g, `RabbitMq retry queue failure - nack-ing message instead`);
+                    channel.nack(msg, undefined, true);
+                }
+            });
+            const config = subscribedMessage.config;
+            const setupResult = yield this.connection.assertQueueAndBindings(channel, config);
+            yield channel.prefetch(config.prefetch === undefined ? 5 : config.prefetch);
+            const queueName = config.queueType === "dead-letter"
+                ? setupResult.dlQueueName
+                : setupResult.queueName;
+            const retryExchangeName = setupResult.retryExchangeName;
+            yield channel.consume(queueName, (m) => {
+                if (m) {
+                    subscribedMessage.busy++;
+                    onRabbitMessage(m)
+                        .catch((err) => {
+                        this.logger.error("Unexpected error handling RabbitMq message", err);
+                        try {
+                            channel.nack(m, undefined, true);
+                        }
+                        catch (err2) {
+                            this.logger.error("Unexpected error handling RabbitMq message during NACK attempt", err2);
+                        }
+                    })
+                        .finally(() => {
+                        subscribedMessage.busy--;
+                    });
+                }
+            });
+            channel.on("error", (err) => {
+                var _a, _b;
+                (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `RabbitMQ consumer error for ${queueName}: ${err}`);
+            });
+            this.logger.log(`RabbitMQ consumer started for ${queueName}`);
+            // stop will cancel the subscriber
+            subscribedMessage.stop = () => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                yield channel.close();
+                (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `RabbitMQ consumer stopped for ${queueName}`);
+            });
+        });
+    }
+}
+exports.RabbitMqSubscriber = RabbitMqSubscriber;

package/dist/rabbitmq/utility.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility function for delay
+ * @param ms
+ * @returns
+ */
+export declare function delay(ms: number): Promise<unknown>;

package/dist/rabbitmq/utility.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+/**
+ * Utility function for delay
+ * @param ms
+ * @returns
+ */
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/subscriber.d.ts

@@ -0,0 +1,28 @@
+import { BaseMessage, Logger, MessageContext, MessageResult, PubSubConfiguration, SubscriberProvider } from "./interfaces";
+export interface SubscriberEventContext {
+    message: string;
+    context: MessageContext;
+    config: PubSubConfiguration;
+}
+export interface MessageHandledEventContext extends SubscriberEventContext {
+    durationMs: number;
+    result?: MessageResult;
+    err?: unknown;
+}
+export interface SubscriberEvents {
+    schemaError: (context: SubscriberEventContext) => void;
+    messageHandled: (context: MessageHandledEventContext) => void;
+}
+export declare class Subscriber {
+    private readonly logger;
+    private subscriberProvdiers;
+    private readonly events;
+    private readonly subscribedMessages;
+    constructor(logger: Logger, providers?: SubscriberProvider[]);
+    on<TU extends keyof SubscriberEvents>(event: TU, listener: SubscriberEvents[TU]): this;
+    subscribe<TMessage extends BaseMessage>(config: PubSubConfiguration, onMessage: (msg: TMessage, context: MessageContext) => Promise<MessageResult> | MessageResult): Promise<void>;
+    unsubscribe(): Promise<void>;
+    addProvider(provider: SubscriberProvider): void;
+    removeProvider(providerOrTransport: SubscriberProvider | string): boolean;
+    close(): Promise<void>;
+}

package/dist/subscriber.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.Subscriber = void 0;
+const interfaces_1 = require("./interfaces");
+const errors_1 = require("./errors");
+const events_1 = require("events");
+class SubscribedMessage {
+    constructor(stop) {
+        this.stop = stop;
+    }
+}
+class Subscriber {
+    constructor(logger, providers) {
+        this.logger = logger;
+        this.subscriberProvdiers = new Map();
+        this.events = new events_1.EventEmitter();
+        this.subscribedMessages = new Map();
+        if (providers) {
+            providers.forEach((provider) => this.subscriberProvdiers.set(provider.transport, provider));
+        }
+    }
+    on(event, listener) {
+        this.events.on(event, listener);
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+    subscribe(config, onMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            let subscribedMessage = this.subscribedMessages.get(config);
+            const schema = config.schema;
+            if (subscribedMessage) {
+                throw new errors_1.AlreadySubscribingError(typeof config);
+            }
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Initializing subscriber for provider ${config.transport}:${config.name}`);
+            const provider = this.subscriberProvdiers.get(config.transport);
+            if (!provider) {
+                throw new errors_1.MissingPubSubProviderError(`No provider configured for ${config.transport}`);
+            }
+            const transform = (jsonStr, context) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const start = new Date().valueOf();
+                const jsonObject = JSON.parse(jsonStr);
+                const r = schema.safeParse(jsonObject);
+                if (!r.success) {
+                    const id = interfaces_1.IdMetaSchema.safeParse(jsonObject);
+                    if (id.success) {
+                        this.logger.warn(`Unable to parse message ${id.data.id} created at ${(_a = id.data.meta) === null || _a === void 0 ? void 0 : _a.createdAt} for ${config.transport}:${config.name} - schemaError`);
+                    }
+                    else {
+                        this.logger.warn(`Unable to parse message for ${config.transport}:${config.name} - schemaError`);
+                    }
+                    const handledEventContext = {
+                        message: jsonStr,
+                        context,
+                        config,
+                        durationMs: new Date().valueOf() - start,
+                        result: interfaces_1.MessageResult.Fail,
+                    };
+                    this.events.emit("schemaError", handledEventContext);
+                    this.events.emit("messageHandled", handledEventContext);
+                    return interfaces_1.MessageResult.Fail;
+                }
+                try {
+                    const result = yield onMessage(r.data, context);
+                    const eventContext = {
+                        message: jsonStr,
+                        context,
+                        config,
+                        durationMs: new Date().valueOf() - start,
+                        result,
+                    };
+                    this.events.emit("messageHandled", eventContext);
+                    return result;
+                }
+                catch (err) {
+                    const eventContext = {
+                        message: jsonStr,
+                        context,
+                        config,
+                        durationMs: new Date().valueOf() - start,
+                        err,
+                    };
+                    this.events.emit("messageHandled", eventContext);
+                    throw err;
+                }
+            });
+            this.logger.log(`Starting subscriber for ${config.transport}:${config.name}`);
+            subscribedMessage = new SubscribedMessage(yield provider.startSubscribe(config, transform));
+            this.subscribedMessages.set(config, subscribedMessage);
+            this.logger.log(`Started subscriber for ${config.transport}:${config.name}`);
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log(`Stopping all ${this.subscribedMessages.size} subscribers`);
+            for (const subscriber of this.subscribedMessages.values()) {
+                yield subscriber.stop();
+            }
+            this.logger.log("Stopped all subscribers");
+            this.subscribedMessages.clear();
+        });
+    }
+    addProvider(provider) {
+        var _a, _b;
+        this.subscriberProvdiers.set(provider.transport, provider);
+        (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Subscriber added provider for ${provider.transport}`);
+    }
+    removeProvider(providerOrTransport) {
+        var _a, _b;
+        let transport;
+        if (typeof providerOrTransport === "string") {
+            transport = providerOrTransport;
+        }
+        else {
+            transport = providerOrTransport.transport;
+        }
+        const result = this.subscriberProvdiers.delete(transport);
+        (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Subscriber removed provider for ${transport}`);
+        return result;
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const provider of this.subscriberProvdiers.values()) {
+                yield provider.close();
+            }
+            this.subscriberProvdiers.clear();
+        });
+    }
+}
+exports.Subscriber = Subscriber;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@palmetto/pubsub",
+  "version": "1.0.0",
+  "main": "./dist/main.js",
+  "scripts": {
+    "lint": "yarn run -T eslint --fix ./src",
+    "format": "yarn run -T prettier --write --loglevel warn .",
+    "tc": "tsc --noEmit",
+    "build": "yarn clean && tsc -p tsconfig.build.json",
+    "clean": "rm -rf ./dist/",
+    "ci:build": "tsc -p tsconfig.build.json",
+    "ci:lint": "yarn run -T eslint . && yarn run -T prettier --check --loglevel warn .",
+    "ci:tc": "yarn tc",
+    "hook:lint": "eslint --cache --fix",
+    "hook:format": "prettier --write --loglevel warn",
+    "hook:tc": "yarn tc",
+    "prepublishOnly": "yarn build",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "redis-up": "docker compose -f redis-compose.yml up -d",
+    "rabbitmq-up": "docker compose -f rabbitmq-compose.yml up -d"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0",
+    "@types/node": "^24.2.1",
+    "amqp-connection-manager": "^4.1.14",
+    "amqplib": "^0.10.8",
+    "bullmq": "^5.58.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4",
+    "zod": "^4.0.5"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "crypto-hash": "^3.1.0",
+    "uuid": "^11.1.0"
+  },
+  "peerDependencies": {
+    "amqp-connection-manager": "^4.1.14",
+    "amqplib": "^0.10.8",
+    "bullmq": "^5.58.0",
+    "zod": "^3.25.0 || ^4.0.0"
+  }
+}