@diia-inhouse/diia-queue 13.3.3 → 14.0.10

package/dist/providers/rabbitmq/amqpListener.js

@@ -1,225 +1,218 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AmqpListener = void 0;
-const errors_1 = require("@diia-inhouse/errors");
-const interfaces_1 = require("../../interfaces");
-const rabbitmq_1 = require("../../interfaces/providers/rabbitmq");
-const metrics_1 = require("../../metrics");
-class AmqpListener {
-    connection;
-    logger;
-    rabbitMQMetrics;
-    queuesOptions;
-    systemServiceName;
-    infiniteRecreateChannelTriesCount = 0;
-    defaultRecreateChannelOptions = {
-        maxTries: 6,
-        timeout: 1000,
-        backoffCoefficient: 2,
-    };
-    defaultPrefetchCount = 1;
-    queuesChannelsMap = new Map();
-    queueRecreateChannelTriesMap = new Map();
-    defaultNackOptions = new interfaces_1.NackOptions(true, false);
-    queuesCallbacksMap = new Map();
-    queueConsumerOptionsMap = new Map();
-    queueConsumerTagsMap = new Map();
-    // in case when we receive a null message, we don't know how-to ack it, and emulate this message.
-    // nothing changes cause previously this case had not been handled
-    nullMessage = { fields: { deliveryTag: 'unknown' } };
-    constructor(connection, logger, rabbitMQMetrics, queuesOptions = [], systemServiceName) {
-        this.connection = connection;
-        this.logger = logger;
-        this.rabbitMQMetrics = rabbitMQMetrics;
-        this.queuesOptions = queuesOptions;
-        this.systemServiceName = systemServiceName;
-        for (const queueOptions of this.queuesOptions) {
-            const { name: queueName, consumerOptions: { prefetchCount, ...consumerOpts } = {} } = queueOptions;
-            this.queueRecreateChannelTriesMap.set(queueName, 0);
-            this.queueConsumerOptionsMap.set(queueName, { ...consumerOpts, prefetchCount: prefetchCount ?? this.defaultPrefetchCount });
-        }
-    }
-    async init() {
-        this.connection.on('ready', async () => {
-            // in case if reconnect happened
-            const tasks = Array.from(this.queuesChannelsMap.keys()).map(async (queueName) => {
-                await this.createChannelAndListenQueue(queueName);
-            });
-            await Promise.all(tasks);
-        });
-    }
-    async cancelQueue(queueName) {
-        const channel = this.getQueueChannel(queueName);
-        const consumerTags = this.queueConsumerTagsMap.get(queueName) || [];
-        for await (const consumerTag of consumerTags) {
-            await channel?.cancel(consumerTag);
-        }
-    }
-    async listenQueue(queueName, callback) {
-        this.logger.debug(`Start listen queue [${queueName}]`);
-        try {
-            this.saveQueueCallback(queueName, callback);
-            await this.createChannelAndListenQueue(queueName);
-        }
-        catch (err) {
-            this.logger.error(`Error while start listen queue [${queueName}]`, { err });
-            throw err;
-        }
-    }
-    getStatus() {
-        return this.connection.getStatus();
-    }
-    ackMsg(channel, message, allUpTo = false) {
-        const msg = message ?? this.nullMessage;
-        return channel.ack(msg, allUpTo);
-    }
-    nackMsg(channel, message, nackOptions) {
-        const { requeue = true, allUpTo = false } = nackOptions;
-        return channel.nack(message, allUpTo, requeue);
-    }
-    async createChannelAndListenQueue(queueName) {
-        const channel = await this.connection.createChannel(queueName);
-        const consumerOptions = this.getConsumerOptions(queueName) || {};
-        const { consumerTag: preferredConsumerTag, prefetchCount = this.defaultPrefetchCount } = consumerOptions;
-        await channel.prefetch(prefetchCount);
-        const callback = this.onMessageCallback(queueName, channel, consumerOptions);
-        channel.on('error', async (err) => {
-            metrics_1.totalListenerChannelErrorsMetric.increment({ queueName });
-            this.logger.warn('Recreating listener channel because an error has been occurred', { err, queueName });
-            await this.handleChannelError(queueName, consumerOptions);
-        });
-        try {
-            const { consumerTag } = await channel.consume(queueName, callback, { consumerTag: preferredConsumerTag });
-            this.saveConsumerTag(queueName, consumerTag);
-            this.logger.info(`Start consuming queue [${queueName}] with consumerTag [${consumerTag}]`);
-        }
-        catch (err) {
-            this.logger.error('Failed to consume queue', { err, queueName });
-            await this.handleChannelError(queueName, consumerOptions);
-        }
-        await this.saveChannel(queueName, channel);
-    }
-    saveQueueCallback(queueName, callback) {
-        this.queuesCallbacksMap.set(queueName, callback);
-    }
-    getQueueCallback(queueName) {
-        const callback = this.queuesCallbacksMap.get(queueName);
-        if (!callback) {
-            const errMsg = `Failed to find callback by queue name [${queueName}]`;
-            this.logger.error(errMsg);
-            throw new Error('Error');
-        }
-        return callback;
-    }
-    async saveChannel(queueName, channel) {
-        try {
-            const oldChannel = this.getQueueChannel(queueName);
-            await oldChannel?.close();
-            this.queuesChannelsMap.set(queueName, channel);
-        }
-        catch (err) {
-            this.logger.error('Failed to close prev channel', { err, queueName });
-        }
-    }
-    onMessageCallback(queueName, channel, consumerOptions) {
-        const callback = this.getQueueCallback(queueName);
-        return async (message) => {
-            const startTime = process.hrtime.bigint();
-            if (message === null) {
-                this.rabbitMQMetrics.collectResponseTotalMetric(startTime, interfaces_1.LabelUnknown, interfaces_1.LabelUnknown, this.systemServiceName, errors_1.ErrorType.Unoperated);
-                await this.handleChannelError(queueName, consumerOptions);
-                return;
-            }
-            this.queueRecreateChannelTriesMap.set(queueName, 0);
-            const [messageData, err] = this.parseMessage(message);
-            const source = message?.properties.headers?.[rabbitmq_1.Headers.sentFrom] || interfaces_1.LabelUnknown;
-            const eventName = messageData?.event || interfaces_1.LabelUnknown;
-            this.rabbitMQMetrics.collectCommunicationsTotalMetric(eventName, source, this.systemServiceName, 'inbound', queueName);
-            if (err || !messageData) {
-                this.rabbitMQMetrics.collectResponseTotalMetric(startTime, eventName, source, this.systemServiceName, errors_1.ErrorType.Unoperated);
-                return this.ackMsg(channel, message);
-            }
-            const response = this.prepareResponse(message, messageData, channel);
-            try {
-                const result = await callback(response);
-                this.rabbitMQMetrics.collectResponseTotalMetric(startTime, eventName, source, this.systemServiceName);
-                return result;
-            }
-            catch (err) {
-                const errorType = err instanceof errors_1.ApiError ? err.getType() : errors_1.ErrorType.Unoperated;
-                this.rabbitMQMetrics.collectResponseTotalMetric(startTime, eventName, source, this.systemServiceName, errorType);
-                throw err;
-            }
-        };
-    }
-    async handleChannelError(queueName, consumerOptions) {
-        const { recreateChannelOptions: { timeout = this.defaultRecreateChannelOptions.timeout, maxTries = this.defaultRecreateChannelOptions.maxTries, backoffCoefficient = this.defaultRecreateChannelOptions.backoffCoefficient, } = {}, } = consumerOptions;
-        const recreateChannelTriesCounter = (this.queueRecreateChannelTriesMap.get(queueName) || 0) + 1;
-        this.queueRecreateChannelTriesMap.set(queueName, recreateChannelTriesCounter);
-        if (maxTries !== this.infiniteRecreateChannelTriesCount && recreateChannelTriesCounter >= maxTries) {
-            throw new Error(`Max recreate channel tries reached [${recreateChannelTriesCounter}] for queue [${queueName}]`);
-        }
-        const waitingTime = timeout * backoffCoefficient * recreateChannelTriesCounter;
-        await new Promise((resolve) => setTimeout(resolve, waitingTime));
-        await this.createChannelAndListenQueue(queueName);
-    }
-    parseMessage(message) {
-        try {
-            const content = message?.content.toString() || '';
-            return [JSON.parse(content), null];
-        }
-        catch (err) {
-            this.logger.error('Error while parse message content', message);
-            return [null, err];
-        }
-    }
-    prepareResponse(message, messageData, channel) {
-        const done = (data) => this.finishResponseProcessing(message, channel, data);
-        return {
-            done,
-            id: message?.properties.messageId,
-            data: messageData,
-            properties: message?.properties,
-            reject: (nackOptions = this.defaultNackOptions) => {
-                this.nackMsg(channel, message, nackOptions);
-            },
-        };
-    }
-    finishResponseProcessing(message, channel, data) {
-        const { replyTo, correlationId } = message.properties;
-        if (data && replyTo && correlationId) {
-            const json = JSON.stringify(data);
-            const content = Buffer.from(json);
-            const options = {
-                correlationId,
-                headers: {
-                    [rabbitmq_1.Headers.handledBy]: this.systemServiceName,
-                },
-            };
-            const exchangeName = '';
-            const routingKey = replyTo;
-            channel.publish(exchangeName, routingKey, content, options);
-        }
-        else if (!data && replyTo && correlationId) {
-            this.logger.warn('Reply to and correlationId headers found but no reply data specified');
-        }
-        this.ackMsg(channel, message);
-    }
-    getConsumerOptions(queueName) {
-        const consumerOptions = this.queueConsumerOptionsMap.get(queueName);
-        if (!consumerOptions) {
-            this.logger.error(`Not found queue [${queueName}] consumer options`);
-            return;
-        }
-        return consumerOptions;
-    }
-    getQueueChannel(queueName) {
-        return this.queuesChannelsMap.get(queueName);
-    }
-    saveConsumerTag(queueName, consumerTag) {
-        const tags = this.queueConsumerTagsMap.get(queueName) || [];
-        this.queueConsumerTagsMap.set(queueName, [...tags, consumerTag]);
-    }
-}
-exports.AmqpListener = AmqpListener;
-//# sourceMappingURL=amqpListener.js.map
+import { Headers, NackOptions } from "../../interfaces/providers/rabbitmq/index.js";
+import { LabelUnknown } from "../../interfaces/metrics/index.js";
+import "../../interfaces/index.js";
+import { totalListenerChannelErrorsMetric } from "../../metrics/index.js";
+import { ApiError, ErrorType } from "@diia-inhouse/errors";
+import { setTimeout } from "node:timers/promises";
+//#region src/providers/rabbitmq/amqpListener.ts
+var AmqpListener = class {
+	connection;
+	logger;
+	rabbitMQMetrics;
+	queuesOptions;
+	systemServiceName;
+	infiniteRecreateChannelTriesCount = 0;
+	defaultRecreateChannelOptions = {
+		maxTries: 6,
+		timeout: 1e3,
+		backoffCoefficient: 2
+	};
+	defaultPrefetchCount = 1;
+	queuesChannelsMap = /* @__PURE__ */ new Map();
+	queueRecreateChannelTriesMap = /* @__PURE__ */ new Map();
+	defaultNackOptions = new NackOptions(true, false);
+	queuesCallbacksMap = /* @__PURE__ */ new Map();
+	queueConsumerOptionsMap = /* @__PURE__ */ new Map();
+	queueConsumerTagsMap = /* @__PURE__ */ new Map();
+	nullMessage = { fields: { deliveryTag: "unknown" } };
+	constructor(connection, logger, rabbitMQMetrics, queuesOptions = [], systemServiceName) {
+		this.connection = connection;
+		this.logger = logger;
+		this.rabbitMQMetrics = rabbitMQMetrics;
+		this.queuesOptions = queuesOptions;
+		this.systemServiceName = systemServiceName;
+		for (const queueOptions of this.queuesOptions) {
+			const { name: queueName, consumerOptions: { prefetchCount, ...consumerOpts } = {} } = queueOptions;
+			this.queueRecreateChannelTriesMap.set(queueName, 0);
+			this.queueConsumerOptionsMap.set(queueName, {
+				...consumerOpts,
+				prefetchCount: prefetchCount ?? this.defaultPrefetchCount
+			});
+		}
+	}
+	async init() {
+		this.connection.on("ready", async () => {
+			const tasks = Array.from(this.queuesChannelsMap.keys()).map(async (queueName) => {
+				await this.createChannelAndListenQueue(queueName);
+			});
+			await Promise.all(tasks);
+		});
+	}
+	async cancelQueue(queueName) {
+		const channel = this.getQueueChannel(queueName);
+		const consumerTags = this.queueConsumerTagsMap.get(queueName) || [];
+		for (const consumerTag of consumerTags) await channel?.cancel(consumerTag);
+	}
+	async listenQueue(queueName, callback) {
+		this.logger.debug(`Start listen queue [${queueName}]`);
+		try {
+			this.saveQueueCallback(queueName, callback);
+			await this.createChannelAndListenQueue(queueName);
+		} catch (err) {
+			this.logger.error(`Error while start listen queue [${queueName}]`, { err });
+			throw err;
+		}
+	}
+	getStatus() {
+		return this.connection.getStatus();
+	}
+	ackMsg(channel, message, allUpTo = false) {
+		const msg = message ?? this.nullMessage;
+		return channel.ack(msg, allUpTo);
+	}
+	nackMsg(channel, message, nackOptions) {
+		const { requeue = true, allUpTo = false } = nackOptions;
+		return channel.nack(message, allUpTo, requeue);
+	}
+	async createChannelAndListenQueue(queueName) {
+		const channel = await this.connection.createChannel(queueName);
+		const consumerOptions = this.getConsumerOptions(queueName) || {};
+		const { consumerTag: preferredConsumerTag, prefetchCount = this.defaultPrefetchCount } = consumerOptions;
+		await channel.prefetch(prefetchCount);
+		const callback = this.onMessageCallback(queueName, channel, consumerOptions);
+		channel.on("error", async (err) => {
+			totalListenerChannelErrorsMetric.increment({ queueName });
+			this.logger.warn("Recreating listener channel because an error has been occurred", {
+				err,
+				queueName
+			});
+			await this.handleChannelError(queueName, consumerOptions);
+		});
+		try {
+			const { consumerTag } = await channel.consume(queueName, callback, { consumerTag: preferredConsumerTag });
+			this.saveConsumerTag(queueName, consumerTag);
+			this.logger.info(`Start consuming queue [${queueName}] with consumerTag [${consumerTag}]`);
+		} catch (err) {
+			this.logger.error("Failed to consume queue", {
+				err,
+				queueName
+			});
+			await this.handleChannelError(queueName, consumerOptions);
+		}
+		await this.saveChannel(queueName, channel);
+	}
+	saveQueueCallback(queueName, callback) {
+		this.queuesCallbacksMap.set(queueName, callback);
+	}
+	getQueueCallback(queueName) {
+		const callback = this.queuesCallbacksMap.get(queueName);
+		if (!callback) {
+			const errMsg = `Failed to find callback by queue name [${queueName}]`;
+			this.logger.error(errMsg);
+			throw new Error("Error");
+		}
+		return callback;
+	}
+	async saveChannel(queueName, channel) {
+		try {
+			await this.getQueueChannel(queueName)?.close();
+			this.queuesChannelsMap.set(queueName, channel);
+		} catch (err) {
+			this.logger.error("Failed to close prev channel", {
+				err,
+				queueName
+			});
+		}
+	}
+	onMessageCallback(queueName, channel, consumerOptions) {
+		const callback = this.getQueueCallback(queueName);
+		return async (message) => {
+			const startTime = process.hrtime.bigint();
+			if (message === null) {
+				this.rabbitMQMetrics.collectResponseTotalMetric(startTime, LabelUnknown, LabelUnknown, this.systemServiceName, ErrorType.Unoperated);
+				await this.handleChannelError(queueName, consumerOptions);
+				return;
+			}
+			this.queueRecreateChannelTriesMap.set(queueName, 0);
+			const [messageData, err] = this.parseMessage(message);
+			const source = message?.properties.headers?.[Headers.sentFrom] || "unknown";
+			const eventName = messageData?.event || "unknown";
+			this.rabbitMQMetrics.collectCommunicationsTotalMetric(eventName, source, this.systemServiceName, "inbound", queueName);
+			if (err || !messageData) {
+				this.rabbitMQMetrics.collectResponseTotalMetric(startTime, eventName, source, this.systemServiceName, ErrorType.Unoperated);
+				return this.ackMsg(channel, message);
+			}
+			const response = this.prepareResponse(message, messageData, channel);
+			try {
+				const result = await callback(response);
+				this.rabbitMQMetrics.collectResponseTotalMetric(startTime, eventName, source, this.systemServiceName);
+				return result;
+			} catch (callbackErr) {
+				const errorType = callbackErr instanceof ApiError ? callbackErr.getType() : ErrorType.Unoperated;
+				this.rabbitMQMetrics.collectResponseTotalMetric(startTime, eventName, source, this.systemServiceName, errorType);
+				throw callbackErr;
+			}
+		};
+	}
+	async handleChannelError(queueName, consumerOptions) {
+		const { recreateChannelOptions: { timeout = this.defaultRecreateChannelOptions.timeout, maxTries = this.defaultRecreateChannelOptions.maxTries, backoffCoefficient = this.defaultRecreateChannelOptions.backoffCoefficient } = {} } = consumerOptions;
+		const recreateChannelTriesCounter = (this.queueRecreateChannelTriesMap.get(queueName) || 0) + 1;
+		this.queueRecreateChannelTriesMap.set(queueName, recreateChannelTriesCounter);
+		if (maxTries !== this.infiniteRecreateChannelTriesCount && recreateChannelTriesCounter >= maxTries) throw new Error(`Max recreate channel tries reached [${recreateChannelTriesCounter}] for queue [${queueName}]`);
+		await setTimeout(timeout * backoffCoefficient * recreateChannelTriesCounter);
+		await this.createChannelAndListenQueue(queueName);
+	}
+	parseMessage(message) {
+		try {
+			const content = message?.content.toString() || "";
+			return [JSON.parse(content), null];
+		} catch (err) {
+			this.logger.error("Error while parse message content", message);
+			return [null, err];
+		}
+	}
+	prepareResponse(message, messageData, channel) {
+		const done = (data) => this.finishResponseProcessing(message, channel, data);
+		return {
+			done,
+			id: message?.properties.messageId,
+			data: messageData,
+			properties: message?.properties,
+			reject: (nackOptions = this.defaultNackOptions) => {
+				this.nackMsg(channel, message, nackOptions);
+			}
+		};
+	}
+	finishResponseProcessing(message, channel, data) {
+		const { replyTo, correlationId } = message.properties;
+		if (data && replyTo && correlationId) {
+			const json = JSON.stringify(data);
+			const content = Buffer.from(json);
+			const options = {
+				correlationId,
+				headers: { [Headers.handledBy]: this.systemServiceName }
+			};
+			const exchangeName = "";
+			const routingKey = replyTo;
+			channel.publish(exchangeName, routingKey, content, options);
+		} else if (!data && replyTo && correlationId) this.logger.warn("Reply to and correlationId headers found but no reply data specified");
+		this.ackMsg(channel, message);
+	}
+	getConsumerOptions(queueName) {
+		const consumerOptions = this.queueConsumerOptionsMap.get(queueName);
+		if (!consumerOptions) {
+			this.logger.error(`Not found queue [${queueName}] consumer options`);
+			return;
+		}
+		return consumerOptions;
+	}
+	getQueueChannel(queueName) {
+		return this.queuesChannelsMap.get(queueName);
+	}
+	saveConsumerTag(queueName, consumerTag) {
+		const tags = this.queueConsumerTagsMap.get(queueName) || [];
+		this.queueConsumerTagsMap.set(queueName, [...tags, consumerTag]);
+	}
+};
+//#endregion
+export { AmqpListener };

package/dist/providers/rabbitmq/amqpPublisher.d.ts

@@ -0,0 +1,38 @@
+import { ExchangeName } from "../../interfaces/messageBrokerServiceConfig.js";
+import { ConnectionStatus } from "../../interfaces/providers/rabbitmq/amqpConnection.js";
+import { AmqpConnection } from "./amqpConnection.js";
+import { PublisherOptions } from "../../interfaces/options.js";
+import { QueueMessageData } from "../../interfaces/providers/rabbitmq/index.js";
+import { MessageHeaders, PublishingResult } from "../../interfaces/providers/rabbitmq/amqpPublisher.js";
+import { RabbitMQMetricsService } from "../../services/metrics.js";
+import { Logger } from "@diia-inhouse/types";
+
+//#region src/providers/rabbitmq/amqpPublisher.d.ts
+declare class AmqpPublisher {
+  private readonly connection;
+  private readonly logger;
+  private readonly rabbitMQMetrics;
+  private readonly systemServiceName;
+  private readonly defaultPublishOptions;
+  private rpcChannel?;
+  private regularChannel?;
+  private readonly replyToQueueName;
+  private eventEmitter?;
+  private readonly directResponseTimeout;
+  constructor(connection: AmqpConnection, logger: Logger, rabbitMQMetrics: RabbitMQMetricsService, systemServiceName: string, options?: PublisherOptions);
+  init(): Promise<void>;
+  publishToExchange(exchangeName: ExchangeName, message: QueueMessageData, headers: MessageHeaders, routingKey?: string): Promise<PublishingResult>;
+  publishToExchangeDirect<T>(exchangeName: ExchangeName, message: QueueMessageData, headers: MessageHeaders, routingKey?: string, responseTimeoutMs?: number): Promise<T>;
+  getStatus(): ConnectionStatus;
+  private createRegularChannel;
+  private createRpcChannel;
+  private listenReplyToQueue;
+  private publishMessage;
+  private publishRequest;
+  private publish;
+  private getPublishOptions;
+  private receiveDirectResponse;
+  private collectMetrics;
+}
+//#endregion
+export { AmqpPublisher };