@diia-inhouse/diia-queue 13.3.4 → 14.0.11

package/dist/providers/rabbitmq/index.js

@@ -1,187 +1,162 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import "../../interfaces/providers/rabbitmq/index.js";
+import "../../interfaces/providers/rabbitmq/amqpConnection.js";
+import { emptyMessageBrokerServiceConfig } from "../../interfaces/messageBrokerServiceConfig.js";
+import "../../interfaces/index.js";
+import constants_default from "../../constants.js";
+import RabbitMQMetricsService from "../../services/metrics.js";
+import { AmqpAsserter } from "./amqpAsserter.js";
+import { AmqpConnection } from "./amqpConnection.js";
+import { AmqpListener } from "./amqpListener.js";
+import { AmqpPublisher } from "./amqpPublisher.js";
+import { InternalServerError } from "@diia-inhouse/errors";
+import lodash from "lodash";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import pTimeout from "p-timeout";
+//#region src/providers/rabbitmq/index.ts
+var RabbitMQProvider = class extends EventEmitter {
+	systemServiceName;
+	rabbitmqConfig;
+	serviceConfig;
+	topicsConfig;
+	portalEvents;
+	logger;
+	metrics;
+	asyncLocalStorage;
+	queuesConfig;
+	messageBrokerServiceConfig;
+	initializingLock;
+	listener;
+	publisher;
+	asserter;
+	connectionList = {
+		["listener"]: {},
+		["asserter"]: {},
+		["publisher"]: {}
+	};
+	publisherIsNotInitializedErrorMsg = "Publisher is not initialized";
+	rabbitMQMetricsService;
+	constructor(systemServiceName, rabbitmqConfig, serviceConfig, topicsConfig, portalEvents, logger, metrics, asyncLocalStorage = void 0, queuesConfig = void 0, messageBrokerServiceConfig = void 0) {
+		super();
+		this.systemServiceName = systemServiceName;
+		this.rabbitmqConfig = rabbitmqConfig;
+		this.serviceConfig = serviceConfig;
+		this.topicsConfig = topicsConfig;
+		this.portalEvents = portalEvents;
+		this.logger = logger;
+		this.metrics = metrics;
+		this.asyncLocalStorage = asyncLocalStorage;
+		this.queuesConfig = queuesConfig;
+		this.messageBrokerServiceConfig = messageBrokerServiceConfig;
+		this.rabbitMQMetricsService = new RabbitMQMetricsService(this.metrics);
+	}
+	getConfig() {
+		return {
+			topics: this.topicsConfig,
+			rabbit: this.rabbitmqConfig,
+			service: this.serviceConfig,
+			portalEvents: this.portalEvents,
+			queues: this.queuesConfig ?? {}
+		};
+	}
+	getMessageBrokerServiceConfig() {
+		if (!this.messageBrokerServiceConfig) return {
+			queuesOptions: [],
+			exchangesOptions: []
+		};
+		return this.messageBrokerServiceConfig;
+	}
+	async init(config = emptyMessageBrokerServiceConfig) {
+		const { queuesOptions, exchangesOptions } = config;
+		if (this.initializingLock) return await this.initializingLock;
+		const tasks = [this.setPublisher(), this.setAsserter(queuesOptions, exchangesOptions)];
+		if (this.rabbitmqConfig.consumerEnabled !== false && queuesOptions.length > 0) tasks.push(this.setListener(queuesOptions));
+		this.initializingLock = Promise.all(tasks).then(() => this.logger.info(`RabbitMQ provider has been initialized by options`, {
+			queuesOptions,
+			exchangesOptions
+		}));
+		await this.initializingLock;
+		this.emit("initialized");
+	}
+	async subscribe(queueName, messageHandler) {
+		await this.listener?.listenQueue(queueName, messageHandler);
+		return true;
+	}
+	async unsubscribe(queueName) {
+		await this.listener?.cancelQueue(queueName);
+	}
+	async publish(message, exchangeName, routingKey = constants_default.DEFAULT_ROUTING_KEY, options) {
+		const { publishTimeout = Infinity, throwOnPublishTimeout = true, delay } = options || {};
+		const publishTask = async () => {
+			const headers = this.preparePublisherHeaders(delay);
+			if (!this.publisher) throw new Error(this.publisherIsNotInitializedErrorMsg);
+			return await this.publisher?.publishToExchange(exchangeName, message, headers, routingKey);
+		};
+		const timeoutMsg = `Publishing message to ${exchangeName} exchange with ${routingKey} routing key timeout exceed`;
+		if (throwOnPublishTimeout) return await pTimeout(publishTask(), publishTimeout, timeoutMsg);
+		return await pTimeout(publishTask(), publishTimeout, () => {
+			this.logger.error(timeoutMsg, { publishTimeout });
+			throw new InternalServerError(timeoutMsg);
+		});
+	}
+	async publishExternalDirect(message, exchangeName, routingKey = constants_default.DEFAULT_ROUTING_KEY, options) {
+		const headers = this.preparePublisherHeaders();
+		if (!this.publisher) throw new Error(this.publisherIsNotInitializedErrorMsg);
+		return await this.publisher?.publishToExchangeDirect(exchangeName, message, headers, routingKey, options?.timeout);
+	}
+	getStatus() {
+		return {
+			...this.listener ? { listener: this.listener.getStatus() } : {},
+			publisher: this.publisher?.getStatus() ?? "down"
+		};
+	}
+	async makeAMQPConnection(client) {
+		return new AmqpConnection(this.rabbitmqConfig.connection, this.logger, this.rabbitmqConfig.reconnectOptions, lodash.merge({ clientProperties: { connectionClientType: client } }, this.rabbitmqConfig.socketOptions));
+	}
+	async makeAMQPListener(queuesOptions) {
+		return new AmqpListener(await this.getConnection("listener"), this.logger, this.rabbitMQMetricsService, queuesOptions, this.systemServiceName);
+	}
+	async makeAMQPAsserter() {
+		return new AmqpAsserter(await this.getConnection("asserter"), this.logger, this.rabbitmqConfig.declareOptions);
+	}
+	async makeAMQPPublisher() {
+		return new AmqpPublisher(await this.getConnection("publisher"), this.logger, this.rabbitMQMetricsService, this.systemServiceName);
+	}
+	async setListener(queuesOptions) {
+		if (!this.listener) {
+			this.listener = await this.makeAMQPListener(queuesOptions);
+			await this.listener?.init();
+		}
+		return this.listener;
+	}
+	async setAsserter(queuesOptions, exchangesOptions) {
+		if (!this.asserter) {
+			this.asserter = await this.makeAMQPAsserter();
+			await this.asserter.init(exchangesOptions, queuesOptions);
+		}
+		return this.asserter;
+	}
+	async setPublisher() {
+		if (!this.publisher) {
+			this.publisher = await this.makeAMQPPublisher();
+			await this.publisher?.init();
+		}
+		return this.publisher;
+	}
+	async getConnection(client) {
+		if (this.connectionList[client].lock) return await this.connectionList[client].lock;
+		const connection = await this.makeAMQPConnection(client);
+		this.connectionList[client].lock = new Promise((resolve) => connection.connect().then(() => resolve(connection)));
+		return await this.connectionList[client].lock;
+	}
+	preparePublisherHeaders(delay) {
+		const logData = (this.asyncLocalStorage?.getStore())?.logData ?? {};
+		return {
+			traceId: logData?.traceId ?? randomUUID(),
+			serviceCode: logData?.serviceCode,
+			...delay ? { "x-delay": delay } : {}
+		};
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RabbitMQProvider = void 0;
-const node_crypto_1 = require("node:crypto");
-const node_events_1 = require("node:events");
-const lodash_1 = require("lodash");
-const p_timeout_1 = __importDefault(require("p-timeout"));
-const errors_1 = require("@diia-inhouse/errors");
-const constants_1 = __importDefault(require("../../constants"));
-const interfaces_1 = require("../../interfaces");
-const rabbitmq_1 = require("../../interfaces/providers/rabbitmq");
-const metrics_1 = __importDefault(require("../../services/metrics"));
-const amqpAsserter_1 = require("./amqpAsserter");
-const amqpConnection_1 = require("./amqpConnection");
-const amqpListener_1 = require("./amqpListener");
-const amqpPublisher_1 = require("./amqpPublisher");
-// eslint-disable-next-line unicorn/prefer-event-target
-class RabbitMQProvider extends node_events_1.EventEmitter {
-    systemServiceName;
-    rabbitmqConfig;
-    serviceConfig;
-    topicsConfig;
-    portalEvents;
-    logger;
-    metrics;
-    asyncLocalStorage;
-    queuesConfig;
-    messageBrokerServiceConfig;
-    initializingLock;
-    listener;
-    publisher;
-    asserter;
-    connectionList = {
-        [rabbitmq_1.ConnectionClientType.Listener]: {},
-        [rabbitmq_1.ConnectionClientType.Asserter]: {},
-        [rabbitmq_1.ConnectionClientType.Publisher]: {},
-    };
-    publisherIsNotInitializedErrorMsg = 'Publisher is not initialized';
-    rabbitMQMetricsService;
-    constructor(systemServiceName, rabbitmqConfig, serviceConfig, topicsConfig, portalEvents, logger, metrics, asyncLocalStorage, queuesConfig, messageBrokerServiceConfig) {
-        super();
-        this.systemServiceName = systemServiceName;
-        this.rabbitmqConfig = rabbitmqConfig;
-        this.serviceConfig = serviceConfig;
-        this.topicsConfig = topicsConfig;
-        this.portalEvents = portalEvents;
-        this.logger = logger;
-        this.metrics = metrics;
-        this.asyncLocalStorage = asyncLocalStorage;
-        this.queuesConfig = queuesConfig;
-        this.messageBrokerServiceConfig = messageBrokerServiceConfig;
-        this.rabbitMQMetricsService = new metrics_1.default(this.metrics);
-    }
-    getConfig() {
-        return {
-            topics: this.topicsConfig,
-            rabbit: this.rabbitmqConfig,
-            service: this.serviceConfig,
-            portalEvents: this.portalEvents,
-            queues: this.queuesConfig ?? {},
-        };
-    }
-    getMessageBrokerServiceConfig() {
-        if (!this.messageBrokerServiceConfig) {
-            return {
-                queuesOptions: [],
-                exchangesOptions: [],
-            };
-        }
-        return this.messageBrokerServiceConfig;
-    }
-    async init(config = interfaces_1.emptyMessageBrokerServiceConfig) {
-        const { queuesOptions, exchangesOptions } = config;
-        if (this.initializingLock) {
-            return await this.initializingLock;
-        }
-        const tasks = [this.setPublisher(), this.setAsserter(queuesOptions, exchangesOptions)];
-        if (this.rabbitmqConfig.consumerEnabled !== false && queuesOptions.length > 0) {
-            tasks.push(this.setListener(queuesOptions));
-        }
-        this.initializingLock = Promise.all(tasks).then(() => this.logger.info(`RabbitMQ provider has been initialized by options`, { queuesOptions, exchangesOptions }));
-        await this.initializingLock;
-        this.emit('initialized');
-    }
-    async subscribe(queueName, messageHandler) {
-        await this.listener?.listenQueue(queueName, messageHandler);
-        return true;
-    }
-    async unsubscribe(queueName) {
-        await this.listener?.cancelQueue(queueName);
-    }
-    async publish(message, exchangeName, routingKey = constants_1.default.DEFAULT_ROUTING_KEY, options) {
-        const { publishTimeout = Infinity, throwOnPublishTimeout = true, delay } = options || {};
-        const publishTask = async () => {
-            const headers = this.preparePublisherHeaders(delay);
-            if (!this.publisher) {
-                throw new Error(this.publisherIsNotInitializedErrorMsg);
-            }
-            return await this.publisher?.publishToExchange(exchangeName, message, headers, routingKey);
-        };
-        const timeoutMsg = `Publishing message to ${exchangeName} exchange with ${routingKey} routing key timeout exceed`;
-        if (throwOnPublishTimeout) {
-            return await (0, p_timeout_1.default)(publishTask(), publishTimeout, timeoutMsg);
-        }
-        return await (0, p_timeout_1.default)(publishTask(), publishTimeout, () => {
-            this.logger.error(timeoutMsg, { publishTimeout });
-            throw new errors_1.InternalServerError(timeoutMsg);
-        });
-    }
-    async publishExternalDirect(message, exchangeName, routingKey = constants_1.default.DEFAULT_ROUTING_KEY, options) {
-        const headers = this.preparePublisherHeaders();
-        if (!this.publisher) {
-            throw new Error(this.publisherIsNotInitializedErrorMsg);
-        }
-        return await this.publisher?.publishToExchangeDirect(exchangeName, message, headers, routingKey, options?.timeout);
-    }
-    getStatus() {
-        return {
-            ...(this.listener ? { listener: this.listener.getStatus() } : {}),
-            publisher: this.publisher?.getStatus() ?? interfaces_1.ConnectionStatus.Down,
-        };
-    }
-    async makeAMQPConnection(client) {
-        return new amqpConnection_1.AmqpConnection(this.rabbitmqConfig.connection, this.logger, this.rabbitmqConfig.reconnectOptions, (0, lodash_1.merge)({
-            clientProperties: {
-                connectionClientType: client,
-            },
-        }, this.rabbitmqConfig.socketOptions));
-    }
-    async makeAMQPListener(queuesOptions) {
-        const connection = await this.getConnection(rabbitmq_1.ConnectionClientType.Listener);
-        return new amqpListener_1.AmqpListener(connection, this.logger, this.rabbitMQMetricsService, queuesOptions, this.systemServiceName);
-    }
-    async makeAMQPAsserter() {
-        const connection = await this.getConnection(rabbitmq_1.ConnectionClientType.Asserter);
-        return new amqpAsserter_1.AmqpAsserter(connection, this.logger, this.rabbitmqConfig.declareOptions);
-    }
-    async makeAMQPPublisher() {
-        const connection = await this.getConnection(rabbitmq_1.ConnectionClientType.Publisher);
-        return new amqpPublisher_1.AmqpPublisher(connection, this.logger, this.rabbitMQMetricsService, this.systemServiceName);
-    }
-    async setListener(queuesOptions) {
-        if (!this.listener) {
-            this.listener = await this.makeAMQPListener(queuesOptions);
-            await this.listener?.init();
-        }
-        return this.listener;
-    }
-    async setAsserter(queuesOptions, exchangesOptions) {
-        if (!this.asserter) {
-            this.asserter = await this.makeAMQPAsserter();
-            await this.asserter.init(exchangesOptions, queuesOptions);
-        }
-        return this.asserter;
-    }
-    async setPublisher() {
-        if (!this.publisher) {
-            this.publisher = await this.makeAMQPPublisher();
-            await this.publisher?.init();
-        }
-        return this.publisher;
-    }
-    async getConnection(client) {
-        if (this.connectionList[client].lock) {
-            return await this.connectionList[client].lock;
-        }
-        const connection = await this.makeAMQPConnection(client);
-        this.connectionList[client].lock = new Promise((resolve) => connection.connect().then(() => resolve(connection)));
-        return await this.connectionList[client].lock;
-    }
-    preparePublisherHeaders(delay) {
-        const store = this.asyncLocalStorage?.getStore();
-        const logData = store?.logData ?? {};
-        const traceId = logData?.traceId ?? (0, node_crypto_1.randomUUID)();
-        const serviceCode = logData?.serviceCode;
-        return {
-            traceId,
-            serviceCode,
-            ...(delay ? { 'x-delay': delay } : {}),
-        };
-    }
-}
-exports.RabbitMQProvider = RabbitMQProvider;
-//# sourceMappingURL=index.js.map
+//#endregion
+export { RabbitMQProvider };

package/dist/services/communicator.d.ts

@@ -0,0 +1,66 @@
+import { ExchangeName, ExchangeOptions, MessageBrokerServiceConfig } from "../interfaces/messageBrokerServiceConfig.js";
+import { PublishOptions } from "../interfaces/options.js";
+import { EventName, QueueName } from "../interfaces/queueConfig/configs.js";
+import { Message, MessageData, QueueMessageData, QueueMessageMetaData } from "../interfaces/providers/rabbitmq/index.js";
+import { MessageHandler } from "../interfaces/messageHandler.js";
+import { MessagePayload, PublishingResult } from "../interfaces/providers/rabbitmq/amqpPublisher.js";
+import { MessageBrokerServiceEventsListener } from "../interfaces/index.js";
+import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
+import { OptionsBuilder } from "./optionsBuilder.js";
+import Logger from "@diia-inhouse/diia-logger";
+
+//#region src/services/communicator.d.ts
+declare abstract class Communicator {
+  protected readonly logger: Logger;
+  protected readonly queueProvider: RabbitMQProvider;
+  protected readonly hostName: string;
+  protected readonly systemServiceName: string;
+  protected readonly optionsBuilder: OptionsBuilder;
+  protected eventNameToExchangeNameMap: Map<EventName, ExchangeName>;
+  private queueBindToMap;
+  private exchangesMap;
+  private serviceConfig;
+  protected constructor(logger: Logger, queueProvider: RabbitMQProvider, hostName: string, systemServiceName: string);
+  onInit(): Promise<void>;
+  onDestroy(): Promise<void>;
+  subscribeToQueues(listeners: MessageBrokerServiceEventsListener[]): Promise<void>;
+  subscribe(queueName: QueueName, messageHandler: MessageHandler): Promise<boolean>;
+  unsubscribeFromQueues(queueNames: string[]): Promise<void>;
+  unsubscribe(queueName: QueueName): Promise<void>;
+  publishToQueue(queueName: QueueName, messageData: MessageData, options?: PublishOptions): Promise<PublishingResult>;
+  publishToExchange(exchangeName: ExchangeName, routingKey: string, messageData: MessageData | Message, options?: PublishOptions): Promise<PublishingResult>;
+  publishEventToExchange(eventName: EventName, payload: MessagePayload, options?: PublishOptions): Promise<PublishingResult>;
+  getPublishQueueMessageData(eventName: EventName, message: MessagePayload, partialMeta?: Partial<QueueMessageMetaData>): QueueMessageData;
+  protected init(): Promise<MessageBrokerServiceConfig>;
+  private buildExchangesMap;
+  private buildEventNameToExchangeNameMap;
+  private getServiceConfig;
+  private unifyServiceConfig;
+  private enrichQueueConsumerOptions;
+  /**
+  * Gets global exchanges options.
+  * This method must be overridden by subclasses to provide a more specific implementation.
+  * @virtual
+  */
+  protected abstract getProducerExchangesOptions(): ExchangeOptions[];
+  /**
+  * Gets unicast event listeners.
+  * This method must be overridden by subclasses to provide a more specific implementation.
+  * @virtual
+  */
+  protected abstract getUnicastListeners(): MessageBrokerServiceEventsListener[];
+  /**
+  * Gets multicast event listeners.
+  * This method must be overridden by subclasses to provide a more specific implementation.
+  * @virtual
+  */
+  protected abstract getMulticastListeners(): MessageBrokerServiceEventsListener[];
+  /**
+  * Gets an exchange name related to a service.
+  * This method must be overridden by subclasses to provide a more specific implementation.
+  * @virtual
+  */
+  protected abstract getExchangeNameWithSuffix(exchangeName: ExchangeName): string;
+}
+//#endregion
+export { Communicator };