@diia-inhouse/diia-queue 13.3.3 → 14.0.10

package/dist/providers/rabbitmq/amqpPublisher.js

@@ -1,192 +1,185 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { Headers } from "../../interfaces/providers/rabbitmq/index.js";
+import { LabelUnknown } from "../../interfaces/metrics/index.js";
+import constants_default from "../../constants.js";
+import { ErrorType, ExternalCommunicatorError, InternalServerError } from "@diia-inhouse/errors";
+import { randomUUID } from "node:crypto";
+import { HttpStatusCode } from "@diia-inhouse/types";
+import { EventEmitter } from "node:events";
+//#region src/providers/rabbitmq/amqpPublisher.ts
+const { APP_ID, DEFAULT_ROUTING_KEY, REPLY_TO_QUEUE_NAME } = constants_default;
+var AmqpPublisher = class {
+	connection;
+	logger;
+	rabbitMQMetrics;
+	systemServiceName;
+	defaultPublishOptions = {
+		contentEncoding: "utf-8",
+		contentType: "application/json",
+		deliveryMode: 2,
+		appId: APP_ID,
+		mandatory: true
+	};
+	rpcChannel;
+	regularChannel;
+	replyToQueueName = REPLY_TO_QUEUE_NAME;
+	eventEmitter;
+	directResponseTimeout = 1e4;
+	constructor(connection, logger, rabbitMQMetrics, systemServiceName, options = {}) {
+		this.connection = connection;
+		this.logger = logger;
+		this.rabbitMQMetrics = rabbitMQMetrics;
+		this.systemServiceName = systemServiceName;
+		this.directResponseTimeout = options.timeout || this.directResponseTimeout;
+		this.replyToQueueName = options.replyToQueueName || REPLY_TO_QUEUE_NAME;
+	}
+	async init() {
+		await this.createRpcChannel();
+		await this.createRegularChannel();
+		this.connection.on("ready", async () => {
+			await this.createRpcChannel();
+			await this.createRegularChannel();
+		});
+	}
+	async publishToExchange(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY) {
+		const { event, payload } = message;
+		const startTime = process.hrtime.bigint();
+		const route = event;
+		const source = this.systemServiceName;
+		const destination = LabelUnknown;
+		try {
+			if (!event || !exchangeName || !payload) {
+				const errorMessage = `Invalid event name [${event}] or exchange name [${exchangeName}] or payload [${JSON.stringify(payload)}]`;
+				this.logger.error(errorMessage);
+				throw new InternalServerError(errorMessage);
+			}
+			const publishOptions = this.getPublishOptions(headers);
+			this.logger.info(`Publish event: ${event}`, {
+				routingKey,
+				delay: headers["x-delay"]
+			});
+			this.logger.io("Event message", message);
+			this.publishMessage(message, exchangeName, routingKey, publishOptions);
+			this.collectMetrics(startTime, route, source, destination);
+		} catch (err) {
+			this.logger.error("Error while publishing event", {
+				err,
+				exchangeName,
+				routingKey
+			});
+			this.collectMetrics(startTime, route, source, destination, ErrorType.Unoperated);
+			throw err;
+		}
+	}
+	async publishToExchangeDirect(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY, responseTimeoutMs = this.directResponseTimeout) {
+		const startTime = process.hrtime.bigint();
+		const route = message.event;
+		const source = this.systemServiceName;
+		let errorType = void 0;
+		let destination = LabelUnknown;
+		try {
+			const { body, headers: { [Headers.handledBy]: handledBy } } = await this.receiveDirectResponse(exchangeName, message, headers, routingKey, responseTimeoutMs);
+			destination = handledBy || destination;
+			return body;
+		} catch (err) {
+			this.logger.error("Failed to receive a direct response", {
+				err,
+				exchangeName,
+				routingKey
+			});
+			errorType = ErrorType.Unoperated;
+			throw err;
+		} finally {
+			this.collectMetrics(startTime, route, source, destination, errorType);
+		}
+	}
+	getStatus() {
+		return this.connection.getStatus();
+	}
+	async createRegularChannel() {
+		this.regularChannel = await this.connection.createChannel();
+	}
+	async createRpcChannel() {
+		this.rpcChannel = await this.connection.createChannel(this.replyToQueueName);
+		this.rpcChannel?.on("error", async () => await this.createRpcChannel());
+		this.eventEmitter = new EventEmitter();
+		this.eventEmitter?.setMaxListeners(0);
+		await this.rpcChannel?.consume(this.replyToQueueName, this.listenReplyToQueue.bind(this), { noAck: true });
+	}
+	listenReplyToQueue(msg) {
+		if (!msg) {
+			this.logger.error("Consumed direct message is null");
+			return;
+		}
+		const body = JSON.parse(msg.content.toString("utf8"));
+		const headers = msg.properties.headers || {};
+		this.eventEmitter?.emit(msg.properties.correlationId, {
+			body,
+			headers
+		});
+	}
+	publishMessage(eventMessage, exchangeName, routingKey, publishOptions) {
+		if (!this.regularChannel) throw new Error("Publishing message is denied, channel is not initialized");
+		return this.publish(eventMessage, exchangeName, routingKey, publishOptions, this.regularChannel);
+	}
+	publishRequest(eventMessage, exchangeName, routingKey, publishOptions) {
+		if (!this.rpcChannel) throw new Error("Publishing RPC request is denied, channel is not initialized");
+		return this.publish(eventMessage, exchangeName, routingKey, publishOptions, this.rpcChannel);
+	}
+	publish(eventMessage, exchangeName, routingKey, publishOptions, channel) {
+		const data = JSON.stringify(eventMessage);
+		const content = Buffer.from(data);
+		if (!channel.publish(exchangeName, routingKey, content, publishOptions)) throw new InternalServerError("Message has not been published");
+	}
+	getPublishOptions(headers, extraOpts = {}) {
+		return {
+			...this.defaultPublishOptions,
+			timestamp: Date.now(),
+			...extraOpts,
+			headers: {
+				...headers,
+				[Headers.sentFrom]: this.systemServiceName
+			}
+		};
+	}
+	async receiveDirectResponse(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY, responseTimeoutMs = this.directResponseTimeout) {
+		const { event, payload } = message;
+		if (!event || !exchangeName || !payload) throw new Error(`Invalid event name [${event}] or exchange name [${exchangeName}] or payload [${JSON.stringify(payload)}]`);
+		const correlationId = randomUUID();
+		const publishOptions = this.getPublishOptions(headers, {
+			correlationId,
+			replyTo: this.replyToQueueName
+		});
+		this.logger.info(`Publish direct event: ${event}`, {
+			routingKey,
+			correlationId,
+			eventUuid: payload.uuid
+		});
+		this.logger.io("Direct event message", message);
+		return await new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.eventEmitter?.removeAllListeners(correlationId);
+				reject(new ExternalCommunicatorError(`Time out for external event: ${event}`, HttpStatusCode.GATEWAY_TIMEOUT));
+			}, responseTimeoutMs);
+			this.eventEmitter?.once(correlationId, (args) => {
+				clearTimeout(timeout);
+				this.logger.info(`Received direct event response: ${event}`, { traceId: headers.traceId });
+				this.logger.io(`Direct event response message`, {
+					body: args.body,
+					traceId: headers.traceId
+				});
+				return resolve(args);
+			});
+			try {
+				this.publishRequest(message, exchangeName, routingKey, publishOptions);
+			} catch (err) {
+				reject(err);
+			}
+		});
+	}
+	collectMetrics(startTime, route, source, destination, errorType) {
+		this.rabbitMQMetrics.collectCommunicationsTotalMetric(route, source, destination, "outbound");
+		this.rabbitMQMetrics.collectRequestTotalMetric(startTime, route, source, destination, errorType);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AmqpPublisher = void 0;
-const node_crypto_1 = require("node:crypto");
-const node_events_1 = require("node:events");
-const errors_1 = require("@diia-inhouse/errors");
-const types_1 = require("@diia-inhouse/types");
-const constants_1 = __importDefault(require("../../constants"));
-const metrics_1 = require("../../interfaces/metrics");
-const rabbitmq_1 = require("../../interfaces/providers/rabbitmq");
-const { APP_ID, DEFAULT_ROUTING_KEY, REPLY_TO_QUEUE_NAME } = constants_1.default;
-class AmqpPublisher {
-    connection;
-    logger;
-    rabbitMQMetrics;
-    systemServiceName;
-    defaultPublishOptions = {
-        // eslint-disable-next-line unicorn/text-encoding-identifier-case
-        contentEncoding: 'utf-8',
-        contentType: 'application/json',
-        // if true, the message will be returned if it is not routed to a queue
-        // i.e., if there are no bindings that match its routing key
-        // meaning persistent
-        deliveryMode: 2,
-        // an arbitrary identifier for the originating application
-        appId: APP_ID,
-        // if true, the message will be returned if it is not routed to a queue
-        // (i.e., if there are no bindings that match its routing key).
-        mandatory: true,
-    };
-    rpcChannel;
-    regularChannel;
-    replyToQueueName = REPLY_TO_QUEUE_NAME;
-    eventEmitter;
-    directResponseTimeout = 10000;
-    constructor(connection, logger, rabbitMQMetrics, systemServiceName, options = {}) {
-        this.connection = connection;
-        this.logger = logger;
-        this.rabbitMQMetrics = rabbitMQMetrics;
-        this.systemServiceName = systemServiceName;
-        this.directResponseTimeout = options.timeout || this.directResponseTimeout;
-        this.replyToQueueName = options.replyToQueueName || REPLY_TO_QUEUE_NAME;
-    }
-    async init() {
-        await this.createRpcChannel();
-        await this.createRegularChannel();
-        this.connection.on('ready', async () => {
-            // in case if reconnect happened
-            await this.createRpcChannel();
-            await this.createRegularChannel();
-        });
-    }
-    async publishToExchange(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY) {
-        const { event, payload } = message;
-        const startTime = process.hrtime.bigint();
-        const route = event;
-        const source = this.systemServiceName;
-        const destination = metrics_1.LabelUnknown;
-        try {
-            if (!event || !exchangeName || !payload) {
-                const message = `Invalid event name [${event}] or exchange name [${exchangeName}] or payload [${JSON.stringify(payload)}]`;
-                this.logger.error(message);
-                throw new errors_1.InternalServerError(message);
-            }
-            const publishOptions = this.getPublishOptions(headers);
-            this.logger.info(`Publish event: ${event}`, { routingKey, delay: headers['x-delay'] });
-            this.logger.io('Event message', message);
-            this.publishMessage(message, exchangeName, routingKey, publishOptions);
-            this.collectMetrics(startTime, route, source, destination);
-        }
-        catch (err) {
-            this.logger.error('Error while publishing event', { err, exchangeName, routingKey });
-            this.collectMetrics(startTime, route, source, destination, errors_1.ErrorType.Unoperated);
-            throw err;
-        }
-    }
-    async publishToExchangeDirect(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY, responseTimeoutMs = this.directResponseTimeout) {
-        const startTime = process.hrtime.bigint();
-        const route = message.event;
-        const source = this.systemServiceName;
-        let errorType = undefined;
-        let destination = metrics_1.LabelUnknown;
-        try {
-            const { body, headers: { [rabbitmq_1.Headers.handledBy]: handledBy }, } = await this.receiveDirectResponse(exchangeName, message, headers, routingKey, responseTimeoutMs);
-            destination = handledBy || destination;
-            return body;
-        }
-        catch (err) {
-            this.logger.error('Failed to receive a direct response', { err, exchangeName, routingKey });
-            errorType = errors_1.ErrorType.Unoperated;
-            throw err;
-        }
-        finally {
-            this.collectMetrics(startTime, route, source, destination, errorType);
-        }
-    }
-    getStatus() {
-        return this.connection.getStatus();
-    }
-    async createRegularChannel() {
-        this.regularChannel = await this.connection.createChannel();
-    }
-    async createRpcChannel() {
-        this.rpcChannel = await this.connection.createChannel(this.replyToQueueName);
-        this.rpcChannel?.on('error', async () => await this.createRpcChannel());
-        // eslint-disable-next-line unicorn/prefer-event-target
-        this.eventEmitter = new node_events_1.EventEmitter();
-        this.eventEmitter?.setMaxListeners(0);
-        const consumeOptions = { noAck: true };
-        await this.rpcChannel?.consume(this.replyToQueueName, this.listenReplyToQueue.bind(this), consumeOptions);
-    }
-    listenReplyToQueue(msg) {
-        if (!msg) {
-            this.logger.error('Consumed direct message is null');
-            return;
-        }
-        const body = JSON.parse(msg.content.toString('utf8'));
-        const headers = msg.properties.headers || {};
-        this.eventEmitter?.emit(msg.properties.correlationId, { body, headers });
-    }
-    publishMessage(eventMessage, exchangeName, routingKey, publishOptions) {
-        if (!this.regularChannel) {
-            throw new Error('Publishing message is denied, channel is not initialized');
-        }
-        return this.publish(eventMessage, exchangeName, routingKey, publishOptions, this.regularChannel);
-    }
-    publishRequest(eventMessage, exchangeName, routingKey, publishOptions) {
-        if (!this.rpcChannel) {
-            throw new Error('Publishing RPC request is denied, channel is not initialized');
-        }
-        return this.publish(eventMessage, exchangeName, routingKey, publishOptions, this.rpcChannel);
-    }
-    publish(eventMessage, exchangeName, routingKey, publishOptions, channel) {
-        const data = JSON.stringify(eventMessage);
-        const content = Buffer.from(data);
-        const isPublishingSuccessful = channel.publish(exchangeName, routingKey, content, publishOptions);
-        if (!isPublishingSuccessful) {
-            throw new errors_1.InternalServerError('Message has not been published');
-        }
-    }
-    getPublishOptions(headers, extraOpts = {}) {
-        return {
-            ...this.defaultPublishOptions,
-            timestamp: Date.now(), // a timestamp for the message
-            ...extraOpts,
-            headers: {
-                ...headers,
-                [rabbitmq_1.Headers.sentFrom]: this.systemServiceName,
-            },
-        };
-    }
-    async receiveDirectResponse(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY, responseTimeoutMs = this.directResponseTimeout) {
-        const { event, payload } = message;
-        if (!event || !exchangeName || !payload) {
-            throw new Error(`Invalid event name [${event}] or exchange name [${exchangeName}] or payload [${JSON.stringify(payload)}]`);
-        }
-        const correlationId = (0, node_crypto_1.randomUUID)();
-        const publishOptions = this.getPublishOptions(headers, {
-            correlationId,
-            replyTo: this.replyToQueueName,
-        });
-        this.logger.info(`Publish direct event: ${event}`, { routingKey, correlationId, eventUuid: payload.uuid });
-        this.logger.io('Direct event message', message);
-        return await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.eventEmitter?.removeAllListeners(correlationId);
-                reject(new errors_1.ExternalCommunicatorError(`Time out for external event: ${event}`, types_1.HttpStatusCode.GATEWAY_TIMEOUT));
-            }, responseTimeoutMs);
-            this.eventEmitter?.once(correlationId, (args) => {
-                clearTimeout(timeout);
-                this.logger.info(`Received direct event response: ${event}`, { traceId: headers.traceId });
-                this.logger.io(`Direct event response message`, { body: args.body, traceId: headers.traceId });
-                return resolve(args);
-            });
-            try {
-                this.publishRequest(message, exchangeName, routingKey, publishOptions);
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-    }
-    collectMetrics(startTime, route, source, destination, errorType) {
-        this.rabbitMQMetrics.collectCommunicationsTotalMetric(route, source, destination, 'outbound');
-        this.rabbitMQMetrics.collectRequestTotalMetric(startTime, route, source, destination, errorType);
-    }
-}
-exports.AmqpPublisher = AmqpPublisher;
-//# sourceMappingURL=amqpPublisher.js.map
+//#endregion
+export { AmqpPublisher };

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

@@ -0,0 +1,56 @@
+import { MessageBrokerServiceConfig, QueueOptions } from "../../interfaces/messageBrokerServiceConfig.js";
+import { AmqpConnection } from "./amqpConnection.js";
+import { PublishDirectOptions, PublishOptions } from "../../interfaces/options.js";
+import { EventName, QueueConfigByQueueName, QueueName, ServiceConfigByConfigType, TopicConfigByConfigType } from "../../interfaces/queueConfig/configs.js";
+import { ConnectionClientType, ExportConfig, QueueMessageData, RabbitMQConfig, RabbitMQStatus } from "../../interfaces/providers/rabbitmq/index.js";
+import { MessageHandler } from "../../interfaces/messageHandler.js";
+import { PublishingResult } from "../../interfaces/providers/rabbitmq/amqpPublisher.js";
+import { QueueContext } from "../../interfaces/queueContext.js";
+import { AmqpAsserter } from "./amqpAsserter.js";
+import { AmqpListener } from "./amqpListener.js";
+import { AmqpPublisher } from "./amqpPublisher.js";
+import { Logger } from "@diia-inhouse/types";
+import { EventEmitter } from "node:events";
+import { MetricsService } from "@diia-inhouse/diia-metrics";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/providers/rabbitmq/index.d.ts
+declare class RabbitMQProvider extends EventEmitter {
+  private readonly systemServiceName;
+  private readonly rabbitmqConfig;
+  private readonly serviceConfig;
+  private readonly topicsConfig;
+  private readonly portalEvents;
+  private readonly logger;
+  private readonly metrics;
+  private readonly asyncLocalStorage;
+  private readonly queuesConfig;
+  private readonly messageBrokerServiceConfig;
+  private initializingLock?;
+  private listener?;
+  private publisher?;
+  private asserter?;
+  private connectionList;
+  private readonly publisherIsNotInitializedErrorMsg;
+  private readonly rabbitMQMetricsService;
+  constructor(systemServiceName: string, rabbitmqConfig: RabbitMQConfig, serviceConfig: ServiceConfigByConfigType, topicsConfig: TopicConfigByConfigType, portalEvents: EventName[], logger: Logger, metrics: MetricsService, asyncLocalStorage?: AsyncLocalStorage<QueueContext> | undefined, queuesConfig?: QueueConfigByQueueName | undefined, messageBrokerServiceConfig?: MessageBrokerServiceConfig | undefined);
+  getConfig(): ExportConfig;
+  getMessageBrokerServiceConfig(): MessageBrokerServiceConfig;
+  init(config?: MessageBrokerServiceConfig): Promise<void>;
+  subscribe(queueName: QueueName, messageHandler: MessageHandler): Promise<boolean>;
+  unsubscribe(queueName: QueueName): Promise<void>;
+  publish(message: QueueMessageData, exchangeName: string, routingKey?: string, options?: PublishOptions): Promise<PublishingResult>;
+  publishExternalDirect<T>(message: QueueMessageData, exchangeName: string, routingKey?: string, options?: PublishDirectOptions): Promise<T>;
+  getStatus(): RabbitMQStatus;
+  makeAMQPConnection(client: ConnectionClientType): Promise<AmqpConnection>;
+  makeAMQPListener(queuesOptions: QueueOptions[]): Promise<AmqpListener>;
+  makeAMQPAsserter(): Promise<AmqpAsserter>;
+  makeAMQPPublisher(): Promise<AmqpPublisher>;
+  private setListener;
+  private setAsserter;
+  private setPublisher;
+  private getConnection;
+  private preparePublisherHeaders;
+}
+//#endregion
+export { RabbitMQProvider };