@diia-inhouse/diia-queue 13.3.4 → 14.0.10

package/dist/services/communicator.js

@@ -1,187 +1,165 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { Message } from "../interfaces/providers/rabbitmq/index.js";
+import "../interfaces/index.js";
+import { getConsumerTag } from "../utils.js";
+import OptionsBuilder from "./optionsBuilder.js";
+import { InternalServerError } from "@diia-inhouse/errors";
+//#region src/services/communicator.ts
+var Communicator = class {
+	logger;
+	queueProvider;
+	hostName;
+	systemServiceName;
+	optionsBuilder;
+	eventNameToExchangeNameMap = /* @__PURE__ */ new Map();
+	queueBindToMap = /* @__PURE__ */ new Map();
+	exchangesMap = /* @__PURE__ */ new Map();
+	serviceConfig = {
+		exchangesOptions: [],
+		queuesOptions: []
+	};
+	constructor(logger, queueProvider, hostName, systemServiceName) {
+		this.logger = logger;
+		this.queueProvider = queueProvider;
+		this.hostName = hostName;
+		this.systemServiceName = systemServiceName;
+		const { queuesOptions = [] } = this.queueProvider.getMessageBrokerServiceConfig();
+		for (const { name: queueName, bindTo } of queuesOptions) this.queueBindToMap.set(queueName, bindTo);
+		this.optionsBuilder = new OptionsBuilder(this.queueProvider);
+	}
+	async onInit() {
+		await this.init();
+	}
+	async onDestroy() {
+		const { queuesOptions } = this.serviceConfig;
+		const queueNames = queuesOptions.map(({ name }) => name);
+		await this.unsubscribeFromQueues(queueNames);
+	}
+	async subscribeToQueues(listeners) {
+		for (const listener of listeners) {
+			const { eventNames, queueOptions: { name: queueName } } = listener;
+			try {
+				await this.subscribe(queueName, listener.handler);
+				this.logger.info(`${this.constructor.name} service listener [${eventNames ? eventNames.join(" ") : queueName}] is initialized successfully`);
+			} catch (err) {
+				this.logger.error(`Failed to initialize ${this.constructor.name} service`, { err });
+				throw err;
+			}
+		}
+	}
+	async subscribe(queueName, messageHandler) {
+		return await this.queueProvider.subscribe(queueName, messageHandler);
+	}
+	async unsubscribeFromQueues(queueNames) {
+		for (const queueName of queueNames) await this.unsubscribe(queueName);
+	}
+	async unsubscribe(queueName) {
+		await this.queueProvider.unsubscribe(queueName);
+	}
+	async publishToQueue(queueName, messageData, options) {
+		const bindTo = [...this.queueBindToMap.get(queueName) ?? []];
+		if (bindTo.length === 0) {
+			const message = `Not found bind options for queue [${queueName}]`;
+			this.logger.error(message);
+			throw new InternalServerError(message);
+		}
+		const queueMessageData = this.getPublishQueueMessageData(messageData.event, messageData.payload);
+		for (const bindOptions of bindTo) {
+			const { exchangeName, routingKey } = bindOptions;
+			await this.queueProvider.publish(queueMessageData, exchangeName, routingKey, options);
+		}
+	}
+	async publishToExchange(exchangeName, routingKey, messageData, options) {
+		if (!this.exchangesMap.has(exchangeName)) {
+			const message = `Not found exchange [${exchangeName}]`;
+			this.logger.error(message);
+			throw new InternalServerError(message);
+		}
+		const message = messageData instanceof Message ? messageData.data : this.getPublishQueueMessageData(messageData.event, messageData.payload);
+		return await this.queueProvider.publish(message, exchangeName, routingKey, options);
+	}
+	async publishEventToExchange(eventName, payload, options) {
+		const exchangeName = this.eventNameToExchangeNameMap.get(eventName);
+		if (!exchangeName) {
+			const message = `Exchange for event [${eventName}] is not defined`;
+			this.logger.error(message);
+			throw new InternalServerError(message);
+		}
+		const { routingKey, ...opts } = options || {};
+		const message = payload instanceof Message ? payload.data : this.getPublishQueueMessageData(eventName, payload);
+		return await this.queueProvider.publish(message, exchangeName, routingKey, opts);
+	}
+	getPublishQueueMessageData(eventName, message, partialMeta) {
+		return {
+			meta: {
+				date: /* @__PURE__ */ new Date(),
+				...partialMeta
+			},
+			event: eventName,
+			payload: message
+		};
+	}
+	async init() {
+		this.buildEventNameToExchangeNameMap();
+		const { rabbit: { consumerEnabled } = {} } = this.queueProvider.getConfig();
+		const producerExchangesOptions = this.getProducerExchangesOptions();
+		const listeners = consumerEnabled === false ? [] : [...this.getMulticastListeners(), ...this.getUnicastListeners()];
+		const serviceConfig = this.getServiceConfig(listeners, producerExchangesOptions);
+		this.serviceConfig = serviceConfig;
+		const { exchangesOptions } = serviceConfig;
+		this.buildExchangesMap(exchangesOptions);
+		await this.queueProvider.init(serviceConfig);
+		await this.subscribeToQueues(listeners);
+		return serviceConfig;
+	}
+	buildExchangesMap(exchangesOptions) {
+		for (const exchangeOptions of exchangesOptions) {
+			const { name } = exchangeOptions;
+			this.exchangesMap.set(name, exchangeOptions);
+		}
+	}
+	buildEventNameToExchangeNameMap() {
+		const { topics } = this.queueProvider.getConfig();
+		for (const topic in topics) {
+			const { events } = topics[topic];
+			const exchangeName = this.getExchangeNameWithSuffix(topic);
+			for (const eventName of events) this.eventNameToExchangeNameMap.set(eventName, exchangeName);
+		}
+	}
+	getServiceConfig(listeners, implicitExchangesOptions = []) {
+		const { queuesOptions, exchangesOptions } = this.unifyServiceConfig(listeners, implicitExchangesOptions);
+		return {
+			exchangesOptions,
+			queuesOptions: queuesOptions.map((queueOptions) => this.enrichQueueConsumerOptions(queueOptions))
+		};
+	}
+	unifyServiceConfig(listeners, implicitExchangesOptions = []) {
+		const queuesMap = /* @__PURE__ */ new Map();
+		const exchangesMap = /* @__PURE__ */ new Map();
+		for (const listener of listeners) {
+			const { queueOptions, exchangesOptions } = listener;
+			queuesMap.set(queueOptions.name, queueOptions);
+			for (const exchangeOptions of exchangesOptions) exchangesMap.set(exchangeOptions.name, exchangeOptions);
+		}
+		const { queuesOptions, exchangesOptions: explicitExchangesOptions } = this.queueProvider.getMessageBrokerServiceConfig();
+		for (const queueOpts of queuesOptions) if (!queuesMap.has(queueOpts.name)) queuesMap.set(queueOpts.name, queueOpts);
+		for (const exchangeOpts of [...explicitExchangesOptions, ...implicitExchangesOptions]) if (!exchangesMap.has(exchangeOpts.name)) exchangesMap.set(exchangeOpts.name, exchangeOpts);
+		return {
+			queuesOptions: [...queuesMap.values()],
+			exchangesOptions: [...exchangesMap.values()]
+		};
+	}
+	enrichQueueConsumerOptions(queueOptions) {
+		const { prefetchCount: globalPrefetchCount } = this.optionsBuilder.defineConsumerOptionsBasedOnGlobalConfig();
+		const { prefetchCount = globalPrefetchCount, consumerTag = getConsumerTag(this.systemServiceName, this.hostName), ...consumerOptions } = queueOptions.consumerOptions || {};
+		return {
+			...queueOptions,
+			consumerOptions: {
+				...consumerOptions,
+				consumerTag,
+				prefetchCount
+			}
+		};
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("@diia-inhouse/errors");
-const interfaces_1 = require("../interfaces");
-const utils_1 = require("../utils");
-const optionsBuilder_1 = __importDefault(require("./optionsBuilder"));
-class Communicator {
-    logger;
-    queueProvider;
-    hostName;
-    systemServiceName;
-    optionsBuilder;
-    eventNameToExchangeNameMap = new Map();
-    queueBindToMap = new Map();
-    exchangesMap = new Map();
-    serviceConfig = {
-        exchangesOptions: [],
-        queuesOptions: [],
-    };
-    constructor(logger, queueProvider, hostName, systemServiceName) {
-        this.logger = logger;
-        this.queueProvider = queueProvider;
-        this.hostName = hostName;
-        this.systemServiceName = systemServiceName;
-        const { queuesOptions = [] } = this.queueProvider.getMessageBrokerServiceConfig();
-        for (const { name: queueName, bindTo } of queuesOptions) {
-            this.queueBindToMap.set(queueName, bindTo);
-        }
-        this.optionsBuilder = new optionsBuilder_1.default(this.queueProvider);
-    }
-    async onInit() {
-        await this.init();
-    }
-    async onDestroy() {
-        const { queuesOptions } = this.serviceConfig;
-        const queueNames = queuesOptions.map(({ name }) => name);
-        await this.unsubscribeFromQueues(queueNames);
-    }
-    async subscribeToQueues(listeners) {
-        for await (const listener of listeners) {
-            const { eventNames, queueOptions: { name: queueName }, } = listener;
-            try {
-                // eslint-disable-next-line unicorn/consistent-destructuring
-                await this.subscribe(queueName, listener.handler);
-                this.logger.info(`${this.constructor.name} service listener [${eventNames ? eventNames.join(' ') : queueName}] is initialized successfully`);
-            }
-            catch (err) {
-                this.logger.error(`Failed to initialize ${this.constructor.name} service`, { err });
-                throw err;
-            }
-        }
-    }
-    async subscribe(queueName, messageHandler) {
-        return await this.queueProvider.subscribe(queueName, messageHandler);
-    }
-    async unsubscribeFromQueues(queueNames) {
-        for await (const queueName of queueNames) {
-            await this.unsubscribe(queueName);
-        }
-    }
-    async unsubscribe(queueName) {
-        await this.queueProvider.unsubscribe(queueName);
-    }
-    async publishToQueue(queueName, messageData, options) {
-        const bindTo = [...(this.queueBindToMap.get(queueName) ?? [])];
-        if (bindTo.length === 0) {
-            const message = `Not found bind options for queue [${queueName}]`;
-            this.logger.error(message);
-            throw new errors_1.InternalServerError(message);
-        }
-        const queueMessageData = this.getPublishQueueMessageData(messageData.event, messageData.payload);
-        for await (const bindOptions of bindTo) {
-            const { exchangeName, routingKey } = bindOptions;
-            await this.queueProvider.publish(queueMessageData, exchangeName, routingKey, options);
-        }
-    }
-    async publishToExchange(exchangeName, routingKey, messageData, options) {
-        if (!this.exchangesMap.has(exchangeName)) {
-            const message = `Not found exchange [${exchangeName}]`;
-            this.logger.error(message);
-            throw new errors_1.InternalServerError(message);
-        }
-        const message = messageData instanceof interfaces_1.Message ? messageData.data : this.getPublishQueueMessageData(messageData.event, messageData.payload);
-        return await this.queueProvider.publish(message, exchangeName, routingKey, options);
-    }
-    async publishEventToExchange(eventName, payload, options) {
-        const exchangeName = this.eventNameToExchangeNameMap.get(eventName);
-        if (!exchangeName) {
-            const message = `Exchange for event [${eventName}] is not defined`;
-            this.logger.error(message);
-            throw new errors_1.InternalServerError(message);
-        }
-        const { routingKey, ...opts } = options || {};
-        const message = payload instanceof interfaces_1.Message ? payload.data : this.getPublishQueueMessageData(eventName, payload);
-        return await this.queueProvider.publish(message, exchangeName, routingKey, opts);
-    }
-    getPublishQueueMessageData(eventName, message, partialMeta) {
-        const meta = {
-            date: new Date(),
-            ...partialMeta,
-        };
-        return {
-            meta,
-            event: eventName,
-            payload: message,
-        };
-    }
-    async init() {
-        this.buildEventNameToExchangeNameMap();
-        const { rabbit: { consumerEnabled } = {} } = this.queueProvider.getConfig();
-        const producerExchangesOptions = this.getProducerExchangesOptions();
-        const listeners = consumerEnabled === false ? [] : [...this.getMulticastListeners(), ...this.getUnicastListeners()];
-        const serviceConfig = this.getServiceConfig(listeners, producerExchangesOptions);
-        this.serviceConfig = serviceConfig;
-        const { exchangesOptions } = serviceConfig;
-        this.buildExchangesMap(exchangesOptions);
-        await this.queueProvider.init(serviceConfig);
-        await this.subscribeToQueues(listeners);
-        return serviceConfig;
-    }
-    buildExchangesMap(exchangesOptions) {
-        for (const exchangeOptions of exchangesOptions) {
-            const { name } = exchangeOptions;
-            this.exchangesMap.set(name, exchangeOptions);
-        }
-    }
-    buildEventNameToExchangeNameMap() {
-        const { topics } = this.queueProvider.getConfig();
-        for (const topic in topics) {
-            const { events } = topics[topic];
-            const exchangeName = this.getExchangeNameWithSuffix(topic);
-            for (const eventName of events) {
-                this.eventNameToExchangeNameMap.set(eventName, exchangeName);
-            }
-        }
-    }
-    getServiceConfig(listeners, implicitExchangesOptions = []) {
-        const { queuesOptions, exchangesOptions } = this.unifyServiceConfig(listeners, implicitExchangesOptions);
-        return {
-            exchangesOptions,
-            queuesOptions: queuesOptions.map((queueOptions) => this.enrichQueueConsumerOptions(queueOptions)),
-        };
-    }
-    unifyServiceConfig(listeners, implicitExchangesOptions = []) {
-        const queuesMap = new Map();
-        const exchangesMap = new Map();
-        for (const listener of listeners) {
-            const { queueOptions, exchangesOptions } = listener;
-            queuesMap.set(queueOptions.name, queueOptions);
-            for (const exchangeOptions of exchangesOptions) {
-                exchangesMap.set(exchangeOptions.name, exchangeOptions);
-            }
-        }
-        const { queuesOptions, exchangesOptions: explicitExchangesOptions } = this.queueProvider.getMessageBrokerServiceConfig();
-        for (const queueOpts of queuesOptions) {
-            if (!queuesMap.has(queueOpts.name)) {
-                queuesMap.set(queueOpts.name, queueOpts);
-            }
-        }
-        for (const exchangeOpts of [...explicitExchangesOptions, ...implicitExchangesOptions]) {
-            if (!exchangesMap.has(exchangeOpts.name)) {
-                exchangesMap.set(exchangeOpts.name, exchangeOpts);
-            }
-        }
-        return {
-            queuesOptions: [...queuesMap.values()],
-            exchangesOptions: [...exchangesMap.values()],
-        };
-    }
-    enrichQueueConsumerOptions(queueOptions) {
-        const { prefetchCount: globalPrefetchCount } = this.optionsBuilder.defineConsumerOptionsBasedOnGlobalConfig();
-        const { prefetchCount = globalPrefetchCount, consumerTag = (0, utils_1.getConsumerTag)(this.systemServiceName, this.hostName), ...consumerOptions } = queueOptions.consumerOptions || {};
-        return {
-            ...queueOptions,
-            consumerOptions: {
-                ...consumerOptions,
-                consumerTag,
-                prefetchCount,
-            },
-        };
-    }
-}
-exports.default = Communicator;
-//# sourceMappingURL=communicator.js.map
+//#endregion
+export { Communicator as default };

package/dist/services/eventBus.d.ts

@@ -0,0 +1,25 @@
+import { ExchangeName, ExchangeOptions } from "../interfaces/messageBrokerServiceConfig.js";
+import { PublishOptions } from "../interfaces/options.js";
+import { EventName, QueueName } from "../interfaces/queueConfig/configs.js";
+import { MessagePayload, PublishingResult } from "../interfaces/providers/rabbitmq/amqpPublisher.js";
+import { EventBusListener, EventBusQueue, MessageBrokerServiceEventsListener } from "../interfaces/index.js";
+import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
+import { Communicator } from "./communicator.js";
+import { EventMessageHandler } from "./eventMessageHandler.js";
+import { OnInit } from "@diia-inhouse/types";
+import Logger$1 from "@diia-inhouse/diia-logger";
+
+//#region src/services/eventBus.d.ts
+declare class EventBus extends Communicator implements EventBusQueue, OnInit {
+  private readonly eventListenerList;
+  private readonly queueName;
+  private readonly eventCommunicator;
+  constructor(queueProvider: RabbitMQProvider, eventListenerList: EventBusListener[], eventMessageHandler: EventMessageHandler, logger: Logger$1, hostName: string, systemServiceName: string, queueName?: QueueName | undefined);
+  publish(eventName: EventName, payload: MessagePayload, options?: PublishOptions): Promise<PublishingResult>;
+  protected getExchangeNameWithSuffix(exchangeName: ExchangeName): string;
+  protected getUnicastListeners(): MessageBrokerServiceEventsListener[];
+  protected getProducerExchangesOptions(): ExchangeOptions[];
+  protected getMulticastListeners(): MessageBrokerServiceEventsListener[];
+}
+//#endregion
+export { EventBus };

package/dist/services/eventBus.js

@@ -1,58 +1,46 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import "../interfaces/messageBrokerServiceConfig.js";
+import "../interfaces/index.js";
+import Communicator from "./communicator.js";
+import { EventCommunicator } from "./eventCommunicator.js";
+//#region src/services/eventBus.ts
+var EventBus = class extends Communicator {
+	eventListenerList;
+	queueName;
+	eventCommunicator;
+	constructor(queueProvider, eventListenerList, eventMessageHandler, logger, hostName, systemServiceName, queueName = void 0) {
+		super(logger, queueProvider, hostName, systemServiceName);
+		this.eventListenerList = eventListenerList;
+		this.queueName = queueName;
+		this.eventCommunicator = new EventCommunicator(logger, queueProvider, eventMessageHandler, eventListenerList);
+	}
+	async publish(eventName, payload, options) {
+		return await this.publishEventToExchange(eventName, payload, options);
+	}
+	getExchangeNameWithSuffix(exchangeName) {
+		return exchangeName;
+	}
+	getUnicastListeners() {
+		return this.eventCommunicator.getUnicastListeners();
+	}
+	getProducerExchangesOptions() {
+		if (!this.queueName) return [];
+		const { rabbit: { declareOptions: { assertExchanges } = {} } } = this.queueProvider.getConfig();
+		const exchangeNames = this.optionsBuilder.getExchangeNamesByQueueName(this.queueName);
+		const exchangesOptions = [];
+		for (const exchangeName of exchangeNames) exchangesOptions.push({
+			name: exchangeName,
+			declare: assertExchanges,
+			type: "topic"
+		});
+		return exchangesOptions;
+	}
+	getMulticastListeners() {
+		if (!this.queueName || this.eventListenerList.length === 0) return [];
+		const [queueOptions] = this.optionsBuilder.defineQueueOptionsBasedOnGlobalConfig(this.queueName);
+		if (!queueOptions) return [];
+		const exchangesOptions = this.getProducerExchangesOptions();
+		return this.eventCommunicator.getMulticastListeners([queueOptions], exchangesOptions);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventBus = void 0;
-const interfaces_1 = require("../interfaces");
-const communicator_1 = __importDefault(require("./communicator"));
-const eventCommunicator_1 = require("./eventCommunicator");
-class EventBus extends communicator_1.default {
-    eventListenerList;
-    queueName;
-    eventCommunicator;
-    constructor(queueProvider, eventListenerList, eventMessageHandler, logger, hostName, systemServiceName, queueName) {
-        super(logger, queueProvider, hostName, systemServiceName);
-        this.eventListenerList = eventListenerList;
-        this.queueName = queueName;
-        this.eventCommunicator = new eventCommunicator_1.EventCommunicator(logger, queueProvider, eventMessageHandler, eventListenerList);
-    }
-    async publish(eventName, payload, options) {
-        return await this.publishEventToExchange(eventName, payload, options);
-    }
-    getExchangeNameWithSuffix(exchangeName) {
-        return exchangeName;
-    }
-    getUnicastListeners() {
-        return this.eventCommunicator.getUnicastListeners();
-    }
-    getProducerExchangesOptions() {
-        if (!this.queueName) {
-            return [];
-        }
-        const { rabbit: { declareOptions: { assertExchanges } = {} }, } = this.queueProvider.getConfig();
-        const exchangeNames = this.optionsBuilder.getExchangeNamesByQueueName(this.queueName);
-        const exchangesOptions = [];
-        for (const exchangeName of exchangeNames) {
-            exchangesOptions.push({
-                name: exchangeName,
-                declare: assertExchanges,
-                type: interfaces_1.ExchangeType.Topic,
-            });
-        }
-        return exchangesOptions;
-    }
-    getMulticastListeners() {
-        if (!this.queueName || this.eventListenerList.length === 0) {
-            return [];
-        }
-        const [queueOptions] = this.optionsBuilder.defineQueueOptionsBasedOnGlobalConfig(this.queueName);
-        if (!queueOptions) {
-            return [];
-        }
-        const exchangesOptions = this.getProducerExchangesOptions();
-        return this.eventCommunicator.getMulticastListeners([queueOptions], exchangesOptions);
-    }
-}
-exports.EventBus = EventBus;
-//# sourceMappingURL=eventBus.js.map
+//#endregion
+export { EventBus };

package/dist/services/eventCommunicator.js

@@ -1,125 +1,76 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { collectEventBusListeners } from "../utils.js";
+import lodash from "lodash";
+//#region src/services/eventCommunicator.ts
+var EventCommunicator = class {
+	logger;
+	queueProvider;
+	eventMessageHandler;
+	listenerList;
+	constructor(logger, queueProvider, eventMessageHandler, listenerList = []) {
+		this.logger = logger;
+		this.queueProvider = queueProvider;
+		this.eventMessageHandler = eventMessageHandler;
+		this.listenerList = listenerList;
+	}
+	getMulticastListeners(queuesOptions, exchangesOptions, eventQueueMap = /* @__PURE__ */ new Map()) {
+		const eventListeners = collectEventBusListeners(this.listenerList);
+		const eventsHandler = this.eventMessageHandler.eventListenersMessageHandler.bind(this.eventMessageHandler, eventListeners);
+		const listeners = [];
+		for (const queueOptions of queuesOptions) {
+			const { name: queueName } = queueOptions;
+			const listener = {
+				eventNames: this.defineEventNamesByQueueName(queueName, eventQueueMap),
+				queueOptions,
+				exchangesOptions,
+				handler: eventsHandler
+			};
+			listeners.push(listener);
+		}
+		return listeners;
+	}
+	getUnicastListeners() {
+		const listeners = [];
+		const { queuesOptions, exchangesOptions } = this.queueProvider.getMessageBrokerServiceConfig();
+		const queuesOptionsMap = lodash.keyBy(queuesOptions, "name");
+		const exchangesOptionsMap = lodash.keyBy(exchangesOptions, "name");
+		for (const eventListener of this.listenerList) {
+			const { queueNames = [] } = eventListener;
+			for (const queueName of queueNames) {
+				const queueOptions = queuesOptionsMap[queueName];
+				if (!queueOptions) {
+					this.logger.error(`Not found queue options by name (${queueName}) for ${this.constructor.name} service`);
+					continue;
+				}
+				const listener = {
+					queueOptions,
+					exchangesOptions: this.defineConsumerExchangesOptions(queueName, queueOptions.bindTo, exchangesOptionsMap),
+					handler: this.eventMessageHandler.eventListenerMessageHandler.bind(this.eventMessageHandler, eventListener)
+				};
+				listeners.push(listener);
+			}
+		}
+		return listeners;
+	}
+	defineConsumerExchangesOptions(queueName, bindTo = [], exchangesMap = {}) {
+		const exchangesOptions = [];
+		for (const bindOptions of bindTo) {
+			const { exchangeName } = bindOptions;
+			const exchangeOptions = exchangesMap[exchangeName];
+			if (!exchangeOptions) {
+				this.logger.error(`Not found exchange options by name (${exchangeName}) for ${this.constructor.name} service`);
+				continue;
+			}
+			exchangesOptions.push(exchangeOptions);
+		}
+		if (exchangesOptions.length === 0) this.logger.error(`Not found exchanges options for queue (${queueName}) for ${this.constructor.name} service`);
+		return exchangesOptions;
+	}
+	defineEventNamesByQueueName(queueName, eventQueueMap) {
+		if (eventQueueMap.size === 0) return this.listenerList.map(({ event }) => event);
+		const eventNames = [];
+		for (const [eventName, eventQueueName] of eventQueueMap) if (eventQueueName === queueName) eventNames.push(eventName);
+		return eventNames;
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventCommunicator = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const Utils = __importStar(require("../utils"));
-class EventCommunicator {
-    logger;
-    queueProvider;
-    eventMessageHandler;
-    listenerList;
-    constructor(logger, queueProvider, eventMessageHandler, listenerList = []) {
-        this.logger = logger;
-        this.queueProvider = queueProvider;
-        this.eventMessageHandler = eventMessageHandler;
-        this.listenerList = listenerList;
-    }
-    getMulticastListeners(queuesOptions, exchangesOptions, eventQueueMap = new Map()) {
-        const eventListeners = Utils.collectEventBusListeners(this.listenerList);
-        const eventsHandler = this.eventMessageHandler.eventListenersMessageHandler.bind(this.eventMessageHandler, eventListeners);
-        const listeners = [];
-        for (const queueOptions of queuesOptions) {
-            const { name: queueName } = queueOptions;
-            const eventNames = this.defineEventNamesByQueueName(queueName, eventQueueMap);
-            const listener = {
-                eventNames,
-                queueOptions,
-                exchangesOptions,
-                handler: eventsHandler,
-            };
-            listeners.push(listener);
-        }
-        return listeners;
-    }
-    getUnicastListeners() {
-        const listeners = [];
-        const { queuesOptions, exchangesOptions } = this.queueProvider.getMessageBrokerServiceConfig();
-        const queuesOptionsMap = lodash_1.default.keyBy(queuesOptions, 'name');
-        const exchangesOptionsMap = lodash_1.default.keyBy(exchangesOptions, 'name');
-        for (const eventListener of this.listenerList) {
-            const { queueNames = [] } = eventListener;
-            for (const queueName of queueNames) {
-                const queueOptions = queuesOptionsMap[queueName];
-                if (!queueOptions) {
-                    this.logger.error(`Not found queue options by name (${queueName}) for ${this.constructor.name} service`);
-                    continue;
-                }
-                const exchangesOptions = this.defineConsumerExchangesOptions(queueName, queueOptions.bindTo, exchangesOptionsMap);
-                const eventMessageHandler = this.eventMessageHandler.eventListenerMessageHandler.bind(this.eventMessageHandler, eventListener);
-                const listener = {
-                    queueOptions,
-                    exchangesOptions,
-                    handler: eventMessageHandler,
-                };
-                listeners.push(listener);
-            }
-        }
-        return listeners;
-    }
-    defineConsumerExchangesOptions(queueName, bindTo = [], exchangesMap = {}) {
-        const exchangesOptions = [];
-        for (const bindOptions of bindTo) {
-            const { exchangeName } = bindOptions;
-            const exchangeOptions = exchangesMap[exchangeName];
-            if (!exchangeOptions) {
-                this.logger.error(`Not found exchange options by name (${exchangeName}) for ${this.constructor.name} service`);
-                continue;
-            }
-            exchangesOptions.push(exchangeOptions);
-        }
-        if (exchangesOptions.length === 0) {
-            this.logger.error(`Not found exchanges options for queue (${queueName}) for ${this.constructor.name} service`);
-        }
-        return exchangesOptions;
-    }
-    defineEventNamesByQueueName(queueName, eventQueueMap) {
-        if (eventQueueMap.size === 0) {
-            return this.listenerList.map(({ event }) => event);
-        }
-        const eventNames = [];
-        for (const [eventName, eventQueueName] of eventQueueMap) {
-            if (eventQueueName === queueName) {
-                eventNames.push(eventName);
-            }
-        }
-        return eventNames;
-    }
-}
-exports.EventCommunicator = EventCommunicator;
-//# sourceMappingURL=eventCommunicator.js.map
+//#endregion
+export { EventCommunicator };