@jsnw/nestjs-rabbitmq 1.0.2 → 1.2.0

package/dist/rabbitmq/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RabbitmqQueue = exports.RabbitmqExchange = exports.Rabbitmq = void 0;
+exports.RabbitmqSubscriber = exports.RabbitmqQueue = exports.RabbitmqExchange = exports.Rabbitmq = void 0;
 var rabbitmq_1 = require("./rabbitmq");
 Object.defineProperty(exports, "Rabbitmq", { enumerable: true, get: function () { return rabbitmq_1.Rabbitmq; } });
 var rabbitmq_exchange_1 = require("./rabbitmq-exchange");
 Object.defineProperty(exports, "RabbitmqExchange", { enumerable: true, get: function () { return rabbitmq_exchange_1.RabbitmqExchange; } });
 var rabbitmq_queue_1 = require("./rabbitmq-queue");
 Object.defineProperty(exports, "RabbitmqQueue", { enumerable: true, get: function () { return rabbitmq_queue_1.RabbitmqQueue; } });
+var rabbitmq_subscriber_1 = require("./rabbitmq-subscriber");
+Object.defineProperty(exports, "RabbitmqSubscriber", { enumerable: true, get: function () { return rabbitmq_subscriber_1.RabbitmqSubscriber; } });

package/dist/rabbitmq/rabbitmq-subscriber.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqSubscriber = void 0;
+const rabbitmq_client_1 = require("rabbitmq-client");
+const common_1 = require("@nestjs/common");
+const rabbitmq_helpers_1 = require("./rabbitmq.helpers");
+class RabbitmqSubscriber {
+    id;
+    connection;
+    params;
+    subscriber;
+    logger;
+    consumer;
+    _isActive;
+    /**
+     * @return {string}
+     */
+    get consumerTag() {
+        return this.consumer.consumerTag;
+    }
+    /**
+     * @return {Consumer["stats"]}
+     */
+    get stats() {
+        return this.consumer.stats;
+    }
+    /**
+     * @return {boolean}
+     */
+    get isActive() {
+        return this._isActive;
+    }
+    /**
+     * @param {string} id
+     * @param {Connection} connection
+     * @param {RabbitmqSubscribeParams} params
+     * @param {RabbitmqSubscriberFunction} subscriber
+     */
+    constructor(id, connection, params, subscriber) {
+        this.id = id;
+        this.connection = connection;
+        this.params = params;
+        this.subscriber = subscriber;
+        this.logger = new common_1.Logger(`${this.constructor.name}(id=${id})`);
+        this._isActive = !params.autoStart;
+        this.consumer = this.connection.createConsumer({
+            queue: params.queue.name,
+            requeue: !!params.requeue,
+            qos: {
+                prefetchSize: params.prefetchSize ?? 0,
+                prefetchCount: params.prefetchCount ?? 1
+            },
+            concurrency: params.concurrency ?? 1,
+            lazy: !!params.autoStart
+        }, this.onMessage);
+    }
+    /**
+     */
+    start() {
+        if (this._isActive)
+            return;
+        this._isActive = true;
+        this.consumer.start();
+    }
+    /**
+     * @return {Promise<void>}
+     */
+    stop() {
+        if (!this._isActive)
+            return Promise.resolve();
+        this._isActive = false;
+        return this.consumer.close();
+    }
+    /**
+     * @param {AsyncMessage} message
+     * @return {Promise<ConsumerStatus>}
+     * @private
+     */
+    onMessage = async (message) => {
+        if (!message.body || (typeof message.body !== 'string' && !Buffer.isBuffer(message.body)))
+            return rabbitmq_client_1.ConsumerStatus.DROP;
+        const messageBody = Buffer.isBuffer(message.body)
+            ? message.body.toString('utf-8')
+            : typeof message.body === 'string'
+                ? message.body
+                : null;
+        if (!messageBody)
+            return rabbitmq_client_1.ConsumerStatus.DROP;
+        const isJSON = message.contentType === 'application/json';
+        let data;
+        try {
+            data = isJSON ? JSON.parse(messageBody) : messageBody;
+        }
+        catch (e) {
+            this.logger.error(`Failed to parse message body as JSON`);
+            return rabbitmq_client_1.ConsumerStatus.DROP;
+        }
+        if (!!this.params.validation?.schema) {
+            const { data: parsed, error, success } = this.params.validation.schema.safeParse(data);
+            if (error || !success)
+                return (0, rabbitmq_helpers_1.mapRabbitmqResponseToConsumerStatus)(this.params.validation.onFail ?? 'drop');
+            data = parsed;
+        }
+        try {
+            const response = await (typeof this.subscriber === 'function'
+                ? this.subscriber(data, message)
+                : this.subscriber.instance[this.subscriber.methodName](data, message));
+            return (0, rabbitmq_helpers_1.mapRabbitmqResponseToConsumerStatus)(response);
+        }
+        catch (e) {
+            this.logger.error(`Error: ${e.constructor.name}(${e.message ?? ''})`);
+            return !!this.params.requeue ? rabbitmq_client_1.ConsumerStatus.REQUEUE : rabbitmq_client_1.ConsumerStatus.DROP;
+        }
+    };
+}
+exports.RabbitmqSubscriber = RabbitmqSubscriber;

package/dist/rabbitmq/rabbitmq.helpers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapRabbitmqResponseToConsumerStatus = void 0;
+const rabbitmq_client_1 = require("rabbitmq-client");
+/**
+ * @param {RabbitmqResponse | string} response
+ * @return {ConsumerStatus}
+ */
+const mapRabbitmqResponseToConsumerStatus = (response) => {
+    response = response.toLowerCase();
+    switch (response) {
+        case 'ack': return rabbitmq_client_1.ConsumerStatus.ACK;
+        case 'requeue': return rabbitmq_client_1.ConsumerStatus.REQUEUE;
+        case 'drop': return rabbitmq_client_1.ConsumerStatus.DROP;
+    }
+    return rabbitmq_client_1.ConsumerStatus.DROP;
+};
+exports.mapRabbitmqResponseToConsumerStatus = mapRabbitmqResponseToConsumerStatus;

package/dist/rabbitmq/rabbitmq.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Rabbitmq = void 0;
 const rabbitmq_client_1 = require("rabbitmq-client");
 const common_1 = require("@nestjs/common");
+const rabbitmq_subscriber_1 = require("./rabbitmq-subscriber");
 class Rabbitmq {
     name;
     logger;
     connection;
     exchanges = new Map();
     queues = new Map();
-    consumers = new Set;
-    consumersById = new Map();
+    subscribers = new Map;
     publisher = null;
     /**
      * @param {string | RabbitmqConstructorParams} arg1
@@ -101,96 +101,81 @@ class Rabbitmq {
             }
         }
     }
+    /**
+     * @param {RabbitmqQueue | string} queue
+     * @return {Promise<RabbitmqQueueStats | null>}
+     */
+    async queueStats(queue) {
+        try {
+            const { messageCount, consumerCount } = await this.connection.queueDeclare({
+                queue: typeof queue === 'string' ? queue : queue.name,
+                passive: true
+            });
+            return { messages: messageCount, consumers: consumerCount };
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    /**
+     * @param {RabbitmqQueue} queue
+     * @return {Promise<number>}
+     */
+    async purgeQueue(queue) {
+        const { messageCount } = await this.connection.queuePurge({
+            queue: queue.name
+        });
+        return messageCount;
+    }
     /**
      * @param {RabbitmqSubscribeParams} params
-     * @param {RabbitmqSubscriber} subscriber
-     * @returns {Promise<void>}
+     * @param {RabbitmqSubscriberFunction} subscriber
+     * @return {Promise<RabbitmqSubscriber>}
      */
     async subscribe(params, subscriber) {
+        const id = params.id ?? (typeof subscriber === 'function'
+            ? Math.random().toString()
+            : subscriber.instance.constructor.name + '.' + subscriber.methodName);
         await this.declareQueue(params.queue);
-        const consumer = this.connection.createConsumer({
-            queue: params.queue.name,
-            requeue: !!params.requeue,
-            qos: {
-                prefetchSize: params.prefetchSize ?? 0,
-                prefetchCount: params.prefetchCount ?? 1
-            },
-            concurrency: params.concurrency ?? 1,
-            lazy: !!params.autoStart
-        }, this.internalConsumer.bind(this, params, subscriber));
-        this.consumers.add(consumer);
-        if (params.id)
-            this.consumersById.set(params.id, { isStarted: !!params.autoStart, consumer: consumer });
+        if (this.subscribers.has(id))
+            throw new Error(`Seems like a subscriber (id: ${id}) already registered`);
+        const rmqSubscriber = new rabbitmq_subscriber_1.RabbitmqSubscriber(id, this.connection, params, subscriber);
+        this.subscribers.set(id, rmqSubscriber);
+        return rmqSubscriber;
+    }
+    /**
+     * @param {string} id
+     * @return {RabbitmqSubscriber | null}
+     */
+    getSubscriberById(id) {
+        return this.subscribers.get(id) ?? null;
     }
     /**
      * @param {string} id
      * @returns {void}
      */
     startSubscriber(id) {
-        const consumer = this.consumersById.get(id);
-        if (!consumer)
+        const subscriber = this.subscribers.get(id);
+        if (!subscriber)
             throw new Error(`Subscriber ${id} not found for connection ${this.name}`);
-        if (consumer.isStarted)
-            return;
-        consumer.isStarted = true;
-        consumer.consumer.start();
+        subscriber.start();
     }
     /**
-     * @returns {void}
+     * @param {string} id
+     * @return {Promise<void>}
      */
-    startPendingSubscribers() {
-        for (const consumer of this.consumersById.values()) {
-            if (consumer.isStarted)
-                continue;
-            consumer.isStarted = true;
-            consumer.consumer.start();
-        }
+    async stopSubscriber(id) {
+        const subscriber = this.subscribers.get(id);
+        if (!subscriber)
+            throw new Error(`Subscriber ${id} not found for connection ${this.name}`);
+        await subscriber.stop();
     }
     /**
-     * @param {RabbitmqSubscribeParams} params
-     * @param {RabbitmqSubscriber} subscriber
-     * @param {AsyncMessage} message
-     * @returns {Promise<ConsumerStatus>}
-     * @private
+     * @returns {void}
      */
-    async internalConsumer(params, subscriber, message) {
-        if (!message.body || (typeof message.body !== 'string' && !Buffer.isBuffer(message.body)))
-            return rabbitmq_client_1.ConsumerStatus.DROP;
-        const messageBody = Buffer.isBuffer(message.body)
-            ? message.body.toString('utf-8')
-            : typeof message.body === 'string'
-                ? message.body
-                : null;
-        if (!messageBody)
-            return rabbitmq_client_1.ConsumerStatus.DROP;
-        const isJSON = message.contentType === 'application/json';
-        let data;
-        try {
-            data = isJSON ? JSON.parse(messageBody) : messageBody;
-        }
-        catch (e) {
-            this.logger.error(`Failed to parse message body as JSON`);
-            return rabbitmq_client_1.ConsumerStatus.DROP;
-        }
-        if (!!params.validation?.schema) {
-            const { data: parsed, error, success } = params.validation.schema.safeParse(data);
-            if (error || !success)
-                return this.mapRabbitmqResponseToConsumerStatus(params.validation.onFail ?? 'drop');
-            data = parsed;
-        }
-        const subscriberName = typeof subscriber === 'function'
-            ? subscriber.name ?? 'anonymous function'
-            : `${subscriber.instance.constructor.name}.${subscriber.methodName}`;
-        try {
-            const response = await (typeof subscriber === 'function'
-                ? subscriber(data, message)
-                : subscriber.instance[subscriber.methodName](data, message));
-            return this.mapRabbitmqResponseToConsumerStatus(response);
-        }
-        catch (e) {
-            this.logger.error(`Error in subscriber ${subscriberName} (connection: ${this.name}). Error: ${e.constructor.name}(${e.message ?? ''})`);
-            return !!params.requeue ? rabbitmq_client_1.ConsumerStatus.REQUEUE : rabbitmq_client_1.ConsumerStatus.DROP;
-        }
+    startPendingSubscribers() {
+        for (const subscriber of this.subscribers.values())
+            subscriber.start();
     }
     /**
      * @param {RabbitmqPublishOptions} options
@@ -207,27 +192,13 @@ class Rabbitmq {
             expiration: options.ttlMs?.toString() ?? undefined
         }, options.type === 'json' ? JSON.stringify(options.message) : options.message);
     }
-    /**
-     * @param {RabbitmqResponse | string} response
-     * @return {ConsumerStatus}
-     * @protected
-     */
-    mapRabbitmqResponseToConsumerStatus(response) {
-        response = response.toLowerCase();
-        switch (response) {
-            case 'ack': return rabbitmq_client_1.ConsumerStatus.ACK;
-            case 'requeue': return rabbitmq_client_1.ConsumerStatus.REQUEUE;
-            case 'drop': return rabbitmq_client_1.ConsumerStatus.DROP;
-        }
-        return rabbitmq_client_1.ConsumerStatus.DROP;
-    }
     /**
      * @return {Promise<void>}
      */
     async close() {
         const promises = [];
-        for (const consumer of this.consumers.values())
-            promises.push(consumer.close());
+        for (const subscriber of this.subscribers.values())
+            promises.push(subscriber.stop());
         promises.push(this.connection.close());
         await Promise.allSettled(promises);
     }

package/dist/types/rabbitmq/index.d.ts

@@ -1,3 +1,4 @@
-export { Rabbitmq, type RabbitmqConstructorParams, type RabbitmqResponse, type RabbitmqSubscribeParams, type RabbitmqMessageValidation, type RabbitmqSubscriber, type RabbitmqPublishOptions } from './rabbitmq';
+export { Rabbitmq, type RabbitmqConstructorParams, type RabbitmqResponse, type RabbitmqSubscribeParams, type RabbitmqMessageValidation, type RabbitmqSubscriberFunction, type RabbitmqPublishOptions, type RabbitmqQueueStats } from './rabbitmq';
 export { RabbitmqExchange, type RabbitmqExchangeType, type RabbitmqExchangeDeclaration } from './rabbitmq-exchange';
 export { RabbitmqQueue, type RabbitmqQueueArguments, type RabbitmqQueueBinding, type RabbitmqQueueDeclaration } from './rabbitmq-queue';
+export { RabbitmqSubscriber } from './rabbitmq-subscriber';

package/dist/types/rabbitmq/rabbitmq-subscriber.d.ts

@@ -0,0 +1,43 @@
+import { type AsyncMessage, Connection, Consumer, ConsumerStatus } from 'rabbitmq-client';
+import type { RabbitmqSubscribeParams, RabbitmqSubscriberFunction } from './rabbitmq';
+export declare class RabbitmqSubscriber {
+    readonly id: string;
+    private readonly connection;
+    private readonly params;
+    private readonly subscriber;
+    private readonly logger;
+    private readonly consumer;
+    private _isActive;
+    /**
+     * @return {string}
+     */
+    get consumerTag(): string;
+    /**
+     * @return {Consumer["stats"]}
+     */
+    get stats(): Consumer['stats'];
+    /**
+     * @return {boolean}
+     */
+    get isActive(): boolean;
+    /**
+     * @param {string} id
+     * @param {Connection} connection
+     * @param {RabbitmqSubscribeParams} params
+     * @param {RabbitmqSubscriberFunction} subscriber
+     */
+    constructor(id: string, connection: Connection, params: RabbitmqSubscribeParams, subscriber: RabbitmqSubscriberFunction);
+    /**
+     */
+    start(): void;
+    /**
+     * @return {Promise<void>}
+     */
+    stop(): Promise<void>;
+    /**
+     * @param {AsyncMessage} message
+     * @return {Promise<ConsumerStatus>}
+     * @private
+     */
+    protected onMessage: (message: AsyncMessage) => Promise<ConsumerStatus>;
+}

package/dist/types/rabbitmq/rabbitmq.d.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
-import { type AsyncMessage, Connection, type Consumer, ConsumerStatus, Publisher } from 'rabbitmq-client';
+import { type AsyncMessage, Connection, Publisher } from 'rabbitmq-client';
 import { RabbitmqExchange } from './rabbitmq-exchange';
 import { RabbitmqQueue } from './rabbitmq-queue';
 import { Logger } from '@nestjs/common';
 import { Jsonifiable } from 'type-fest';
+import { RabbitmqSubscriber } from './rabbitmq-subscriber';
 export type RabbitmqConstructorParams = {
     name: string;
     /**
@@ -18,6 +19,10 @@ export type RabbitmqConstructorParams = {
     connectionTimeout?: number;
 };
 export type RabbitmqResponse = 'ack' | 'drop' | 'requeue';
+export type RabbitmqQueueStats = {
+    messages: number;
+    consumers: number;
+};
 export type RabbitmqMessageValidation = {
     schema: z.ZodTypeAny;
     onFail?: RabbitmqResponse;
@@ -36,7 +41,7 @@ export type RabbitmqSubscribeParams = {
     id?: never;
     autoStart?: never;
 });
-export type RabbitmqSubscriber = {
+export type RabbitmqSubscriberFunction = {
     instance: any;
     methodName: string;
 } | ((data: any, message: AsyncMessage) => RabbitmqResponse | Promise<RabbitmqResponse>);
@@ -58,11 +63,7 @@ export declare class Rabbitmq {
     protected readonly connection: Connection;
     protected readonly exchanges: Map<string, RabbitmqExchange>;
     protected readonly queues: Map<string, RabbitmqQueue>;
-    protected readonly consumers: Set<Consumer>;
-    protected readonly consumersById: Map<string, {
-        isStarted: boolean;
-        consumer: Consumer;
-    }>;
+    protected readonly subscribers: Map<string, RabbitmqSubscriber>;
     protected publisher: Publisher | null;
     constructor(name: string, connection: Connection);
     constructor(params: RabbitmqConstructorParams);
@@ -82,40 +83,46 @@ export declare class Rabbitmq {
      * @protected
      */
     protected setupQueueBindings(queue: RabbitmqQueue): Promise<void>;
+    /**
+     * @param {RabbitmqQueue | string} queue
+     * @return {Promise<RabbitmqQueueStats | null>}
+     */
+    queueStats(queue: RabbitmqQueue | string): Promise<RabbitmqQueueStats | null>;
+    /**
+     * @param {RabbitmqQueue} queue
+     * @return {Promise<number>}
+     */
+    purgeQueue(queue: RabbitmqQueue): Promise<number>;
     /**
      * @param {RabbitmqSubscribeParams} params
-     * @param {RabbitmqSubscriber} subscriber
-     * @returns {Promise<void>}
+     * @param {RabbitmqSubscriberFunction} subscriber
+     * @return {Promise<RabbitmqSubscriber>}
+     */
+    subscribe(params: RabbitmqSubscribeParams, subscriber: RabbitmqSubscriberFunction): Promise<RabbitmqSubscriber>;
+    /**
+     * @param {string} id
+     * @return {RabbitmqSubscriber | null}
      */
-    subscribe(params: RabbitmqSubscribeParams, subscriber: RabbitmqSubscriber): Promise<void>;
+    getSubscriberById(id: string): RabbitmqSubscriber | null;
     /**
      * @param {string} id
      * @returns {void}
      */
     startSubscriber(id: string): void;
     /**
-     * @returns {void}
+     * @param {string} id
+     * @return {Promise<void>}
      */
-    startPendingSubscribers(): void;
+    stopSubscriber(id: string): Promise<void>;
     /**
-     * @param {RabbitmqSubscribeParams} params
-     * @param {RabbitmqSubscriber} subscriber
-     * @param {AsyncMessage} message
-     * @returns {Promise<ConsumerStatus>}
-     * @private
+     * @returns {void}
      */
-    private internalConsumer;
+    startPendingSubscribers(): void;
     /**
      * @param {RabbitmqPublishOptions} options
      * @return {Promise<void>}
      */
     publish(options: RabbitmqPublishOptions): Promise<void>;
-    /**
-     * @param {RabbitmqResponse | string} response
-     * @return {ConsumerStatus}
-     * @protected
-     */
-    protected mapRabbitmqResponseToConsumerStatus(response: RabbitmqResponse | string): ConsumerStatus;
     /**
      * @return {Promise<void>}
      */

package/dist/types/rabbitmq/rabbitmq.helpers.d.ts

@@ -0,0 +1,7 @@
+import { ConsumerStatus } from 'rabbitmq-client';
+import { type RabbitmqResponse } from './rabbitmq';
+/**
+ * @param {RabbitmqResponse | string} response
+ * @return {ConsumerStatus}
+ */
+export declare const mapRabbitmqResponseToConsumerStatus: (response: RabbitmqResponse | string) => ConsumerStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsnw/nestjs-rabbitmq",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "NestJS module for RabbitMQ integration with decorator-based consumers, message validation, and dead-letter exchange support",
   "main": "./dist/index.js",
   "types": "./dist/types/index.d.ts",