@diia-inhouse/diia-queue 13.3.4 → 14.0.10

package/dist/services/externalCommunicator.js

@@ -1,140 +1,149 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalCommunicator = void 0;
-const node_crypto_1 = require("node:crypto");
-const errors_1 = require("@diia-inhouse/errors");
-class ExternalCommunicator {
-    externalEventBus;
-    eventMessageValidator;
-    logger;
-    constructor(externalEventBus, eventMessageValidator, logger) {
-        this.externalEventBus = externalEventBus;
-        this.eventMessageValidator = eventMessageValidator;
-        this.logger = logger;
-    }
-    /**
-     * Synchronous request/response over the external event bus.
-     *
-     * Publishes `event` to the configured external exchange wrapped as
-     * `{ uuid, request }` and awaits the subscriber's response on the same call.
-     * The response envelope is validated against `ops.validationRules`, and any embedded error is rethrown as
-     * {@link ExternalCommunicatorError}.
-     *
-     * Use this when the caller needs the response inline (e.g. a user-facing
-     * request that must block on `AGateway`). For fire-and-forget or fan-out
-     * flows, use the `default` publish + listener pattern instead.
-     *
-     * ### Transport
-     *
-     * Implemented on top of RabbitMQ's
-     * [direct reply-to](https://www.rabbitmq.com/docs/direct-reply-to)
-     * feature: the publisher consumes the pseudo-queue
-     * `amq.rabbitmq.reply-to` and stamps each request with `replyTo` +
-     * `correlationId`. The subscriber publishes its response back to that
-     * `replyTo` on the default exchange, and this call resolves when the
-     * matching `correlationId` arrives. No reply queue is declared per
-     * request, so there is no per-call broker setup overhead.
-     *
-     * ### Response contract
-     *
-     * The subscriber must respond with an
-     * {@link ExternalCommunicatorResponse} envelope:
-     *
-     * ```ts
-     * { uuid: string, response: T, error?: { http_code, message?, data? } }
-     * ```
-     *
-     * On success this method returns **only the `response` field** typed as
-     * `T` — the wrapping `uuid` and the envelope itself are not exposed to
-     * the caller. Therefore `T` should describe the shape of `response`, not
-     * of the full envelope.
-     *
-     * ### Error contract
-     *
-     * Errors travel through the same envelope (`error` field on the
-     * subscriber's response — this is **not** a transport-level failure),
-     * but on the caller side they are surfaced as a thrown
-     * {@link ExternalCommunicatorError} instead of being returned. The
-     * envelope's `error` payload is mapped onto the exception so no data is
-     * lost:
-     *
-     * - `error.message` → `Error.message` (falls back to `'unknown error'`
-     *   when missing).
-     * - `error.http_code` → exception's status code (read via `getCode()`).
-     * - `error.data` → exception's data bag (read via `getData()`), spread
-     *   alongside `event` (the event name) and `httpCode` (a duplicate of
-     *   the status code, kept on `data` for downstream consumers).
-     *
-     * Callers that need to inspect the original status or payload should
-     * `catch` the error and read those fields:
-     *
-     * ```ts
-     * try {
-     *     await externalCommunicator.receiveDirect<T>(event, req, ops)
-     * } catch (err) {
-     *     if (err instanceof ExternalCommunicatorError) {
-     *         err.getCode() // original error.http_code
-     *         err.getData() // { event, httpCode, ...error.data }
-     *         err.message   // error.message || 'unknown error'
-     *     }
-     *     throw err
-     * }
-     * ```
-     *
-     * @typeParam T - shape of the successful `response` payload returned by the subscriber.
-     * @param event - external event name. Must be declared in
-     *     `serviceRulesConfig.topicsConfig[QueueConfigType.External][topicName].events[]`
-     *     so the event resolves to an exchange (or pass `ops.exchangeName`
-     *     to override the lookup).
-     * @param request - payload forwarded to the subscriber. Defaults to `{}`.
-     * @param ops - direct-call options. See {@link ReceiveDirectOps}.
-     * @returns the subscriber's `response` field, typed as `T`. The envelope's
-     *     `uuid` and `error` fields are not returned.
-     *
-     * @throws {ExternalCommunicatorError} when the subscriber responds with an
-     *     `error` envelope. The original `http_code`, `message`, and `data`
-     *     fields are preserved on the thrown error.
-     * @throws {Error} `'Message in a wrong format was received from a direct channel'`
-     *     when `validationRules` are provided and the response fails validation.
-     *
-     * @example
-     * ```ts
-     * const result = await externalCommunicator.receiveDirect<{ data: string }>(
-     *     'notary.lookup',
-     *     { notaryCertificateNumber: '1234', requestId: '-0' },
-     *     {
-     *         // Describes the inner `response` only; the envelope (uuid,
-     *         // error, meta, ...) is wrapped by the validator.
-     *         validationRules: { data: { type: 'string' } },
-     *         timeout: DurationMs.Second * 5,
-     *     },
-     * )
-     * ```
-     */
-    async receiveDirect(event, request = {}, ops) {
-        const { exchangeName, validationRules, ignoreCache, timeout, registryApiVersion, requestUuid = (0, node_crypto_1.randomUUID)() } = ops;
-        const payload = { uuid: requestUuid, request };
-        const options = { ignoreCache, timeout, exchangeName, registryApiVersion };
-        const externalResponse = await this.externalEventBus.publishDirect(event, payload, options);
-        this.logger.debug('External direct response', externalResponse);
-        if (validationRules) {
-            try {
-                this.eventMessageValidator.validateSyncedEventMessage(externalResponse, validationRules);
-            }
-            catch (err) {
-                const errorMsg = 'Message in a wrong format was received from a direct channel';
-                this.logger.error(errorMsg, { err, externalResponse });
-                throw new Error(errorMsg);
-            }
-        }
-        const { error, response } = externalResponse.payload;
-        if (error) {
-            this.logger.error(`Error received by an external event ${event}: ${error.http_code} ${error.message}`, { requestUuid });
-            const errMsg = error.message || 'unknown error';
-            throw new errors_1.ExternalCommunicatorError(errMsg, error.http_code, { event, httpCode: error.http_code, ...error.data });
-        }
-        return response;
-    }
-}
-exports.ExternalCommunicator = ExternalCommunicator;
-//# sourceMappingURL=externalCommunicator.js.map
+import { ExternalCommunicatorError } from "@diia-inhouse/errors";
+import { randomUUID } from "node:crypto";
+//#region src/services/externalCommunicator.ts
+var ExternalCommunicator = class {
+	externalEventBus;
+	eventMessageValidator;
+	logger;
+	constructor(externalEventBus, eventMessageValidator, logger) {
+		this.externalEventBus = externalEventBus;
+		this.eventMessageValidator = eventMessageValidator;
+		this.logger = logger;
+	}
+	/**
+	* Synchronous request/response over the external event bus.
+	*
+	* Publishes `event` to the configured external exchange wrapped as
+	* `{ uuid, request }` and awaits the subscriber's response on the same call.
+	* The response envelope is validated against `ops.validationRules`, and any embedded error is rethrown as
+	* {@link ExternalCommunicatorError}.
+	*
+	* Use this when the caller needs the response inline (e.g. a user-facing
+	* request that must block on `AGateway`). For fire-and-forget or fan-out
+	* flows, use the `default` publish + listener pattern instead.
+	*
+	* ### Transport
+	*
+	* Implemented on top of RabbitMQ's
+	* [direct reply-to](https://www.rabbitmq.com/docs/direct-reply-to)
+	* feature: the publisher consumes the pseudo-queue
+	* `amq.rabbitmq.reply-to` and stamps each request with `replyTo` +
+	* `correlationId`. The subscriber publishes its response back to that
+	* `replyTo` on the default exchange, and this call resolves when the
+	* matching `correlationId` arrives. No reply queue is declared per
+	* request, so there is no per-call broker setup overhead.
+	*
+	* ### Response contract
+	*
+	* The subscriber must respond with an
+	* {@link ExternalCommunicatorResponse} envelope:
+	*
+	* ```ts
+	* { uuid: string, response: T, error?: { http_code, message?, data? } }
+	* ```
+	*
+	* On success this method returns **only the `response` field** typed as
+	* `T` — the wrapping `uuid` and the envelope itself are not exposed to
+	* the caller. Therefore `T` should describe the shape of `response`, not
+	* of the full envelope.
+	*
+	* ### Error contract
+	*
+	* Errors travel through the same envelope (`error` field on the
+	* subscriber's response — this is **not** a transport-level failure),
+	* but on the caller side they are surfaced as a thrown
+	* {@link ExternalCommunicatorError} instead of being returned. The
+	* envelope's `error` payload is mapped onto the exception so no data is
+	* lost:
+	*
+	* - `error.message` → `Error.message` (falls back to `'unknown error'`
+	*   when missing).
+	* - `error.http_code` → exception's status code (read via `getCode()`).
+	* - `error.data` → exception's data bag (read via `getData()`), spread
+	*   alongside `event` (the event name) and `httpCode` (a duplicate of
+	*   the status code, kept on `data` for downstream consumers).
+	*
+	* Callers that need to inspect the original status or payload should
+	* `catch` the error and read those fields:
+	*
+	* ```ts
+	* try {
+	*     await externalCommunicator.receiveDirect<T>(event, req, ops)
+	* } catch (err) {
+	*     if (err instanceof ExternalCommunicatorError) {
+	*         err.getCode() // original error.http_code
+	*         err.getData() // { event, httpCode, ...error.data }
+	*         err.message   // error.message || 'unknown error'
+	*     }
+	*     throw err
+	* }
+	* ```
+	*
+	* @typeParam T - shape of the successful `response` payload returned by the subscriber.
+	* @param event - external event name. Must be declared in
+	*     `serviceRulesConfig.topicsConfig[QueueConfigType.External][topicName].events[]`
+	*     so the event resolves to an exchange (or pass `ops.exchangeName`
+	*     to override the lookup).
+	* @param request - payload forwarded to the subscriber. Defaults to `{}`.
+	* @param ops - direct-call options. See {@link ReceiveDirectOps}.
+	* @returns the subscriber's `response` field, typed as `T`. The envelope's
+	*     `uuid` and `error` fields are not returned.
+	*
+	* @throws {ExternalCommunicatorError} when the subscriber responds with an
+	*     `error` envelope. The original `http_code`, `message`, and `data`
+	*     fields are preserved on the thrown error.
+	* @throws {Error} `'Message in a wrong format was received from a direct channel'`
+	*     when `validationRules` are provided and the response fails validation.
+	*
+	* @example
+	* ```ts
+	* const result = await externalCommunicator.receiveDirect<{ data: string }>(
+	*     'notary.lookup',
+	*     { notaryCertificateNumber: '1234', requestId: '-0' },
+	*     {
+	*         // Describes the inner `response` only; the envelope (uuid,
+	*         // error, meta, ...) is wrapped by the validator.
+	*         validationRules: { data: { type: 'string' } },
+	*         timeout: DurationMs.Second * 5,
+	*     },
+	* )
+	* ```
+	*/
+	async receiveDirect(event, request = {}, ops) {
+		const { exchangeName, validationRules, ignoreCache, timeout, registryApiVersion, requestUuid = randomUUID() } = ops;
+		const payload = {
+			uuid: requestUuid,
+			request
+		};
+		const options = {
+			ignoreCache,
+			timeout,
+			exchangeName,
+			registryApiVersion
+		};
+		const externalResponse = await this.externalEventBus.publishDirect(event, payload, options);
+		this.logger.debug("External direct response", externalResponse);
+		if (validationRules) try {
+			this.eventMessageValidator.validateSyncedEventMessage(externalResponse, validationRules);
+		} catch (err) {
+			const errorMsg = "Message in a wrong format was received from a direct channel";
+			this.logger.error(errorMsg, {
+				err,
+				externalResponse
+			});
+			throw new Error(errorMsg, { cause: err });
+		}
+		const { error, response } = externalResponse.payload;
+		if (error) {
+			this.logger.error(`Error received by an external event ${event}: ${error.http_code} ${error.message}`, { requestUuid });
+			throw new ExternalCommunicatorError(error.message || "unknown error", error.http_code, {
+				event,
+				httpCode: error.http_code,
+				...error.data
+			});
+		}
+		return response;
+	}
+};
+//#endregion
+export { ExternalCommunicator };

package/dist/services/externalEventBus.d.ts

@@ -0,0 +1,39 @@
+import { ExchangeName, ExchangeOptions } from "../interfaces/messageBrokerServiceConfig.js";
+import { PublishDirectOptions, PublishOptions } from "../interfaces/options.js";
+import { EventName } from "../interfaces/queueConfig/configs.js";
+import { MessagePayload, PublishingResult } from "../interfaces/providers/rabbitmq/amqpPublisher.js";
+import { EventBusListener, ExternalEventBusQueue, 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";
+import { EnvService } from "@diia-inhouse/env";
+
+//#region src/services/externalEventBus.d.ts
+declare class ExternalEventBus extends Communicator implements ExternalEventBusQueue, OnInit {
+  private readonly envService;
+  private readonly eventCommunicator;
+  private readonly publishEventsSet;
+  private readonly subscribeEventsSet;
+  private readonly exchangePrefixName;
+  private readonly eventQueueMap;
+  constructor(logger: Logger$1, systemServiceName: string, envService: EnvService, queueProvider: RabbitMQProvider, externalEventListenerList: EventBusListener[], eventMessageHandler: EventMessageHandler, hostName: string);
+  static BuildRequestRoutingKey(eventName: string): string;
+  static BuildResponseRoutingKey(eventName: EventName, portalEvents?: string[]): string;
+  private static prepareQueuePrefix;
+  publish(eventName: EventName, payload: MessagePayload, options?: PublishOptions): Promise<PublishingResult>;
+  publishDirect<T>(eventName: EventName, payload: MessagePayload, options?: PublishDirectOptions): Promise<T>;
+  protected getUnicastListeners(): MessageBrokerServiceEventsListener[];
+  protected getExchangeNameWithSuffix(topic: ExchangeName): string;
+  protected getProducerExchangesOptions(): ExchangeOptions[];
+  protected override getMulticastListeners(): MessageBrokerServiceEventsListener[];
+  private getPublishMessage;
+  private getPublishRoutingKey;
+  private defineQueuesAndExchangesOptionsBasedOnGlobalConfig;
+  private buildEventQueueMap;
+  private buildResponseQueueName;
+  private buildRequestQueueName;
+}
+//#endregion
+export { ExternalEventBus };

package/dist/services/externalEventBus.js

@@ -1,163 +1,145 @@
-"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 { QueueTypes } from "../interfaces/messageBrokerServiceConfig.js";
+import "../interfaces/index.js";
+import constants_default from "../constants.js";
+import Communicator from "./communicator.js";
+import { EventCommunicator } from "./eventCommunicator.js";
+import { ErrorType, ExternalCommunicatorError } from "@diia-inhouse/errors";
+import { HttpStatusCode } from "@diia-inhouse/types";
+//#region src/services/externalEventBus.ts
+var ExternalEventBus = class ExternalEventBus extends Communicator {
+	envService;
+	eventCommunicator;
+	publishEventsSet;
+	subscribeEventsSet;
+	exchangePrefixName = "TopicExternal";
+	eventQueueMap = /* @__PURE__ */ new Map();
+	constructor(logger, systemServiceName, envService, queueProvider, externalEventListenerList, eventMessageHandler, hostName) {
+		super(logger, queueProvider, hostName, systemServiceName);
+		this.envService = envService;
+		const { rabbit: { custom }, service: { publish = [], subscribe = [] } } = this.queueProvider.getConfig();
+		if (custom?.responseRoutingKeyPrefix && !this.envService.isLocal() && !this.envService.isTest()) throw new Error("Response routing key could be used only on local env");
+		this.publishEventsSet = new Set(publish);
+		this.subscribeEventsSet = new Set(subscribe);
+		this.eventQueueMap = this.buildEventQueueMap();
+		this.eventCommunicator = new EventCommunicator(logger, queueProvider, eventMessageHandler, externalEventListenerList);
+	}
+	static BuildRequestRoutingKey(eventName) {
+		return `queue.${constants_default.PROJECT_NAME}.${eventName}.req`;
+	}
+	static BuildResponseRoutingKey(eventName, portalEvents = []) {
+		return `${ExternalEventBus.prepareQueuePrefix(eventName, portalEvents)}.${eventName}.res`;
+	}
+	static prepareQueuePrefix(event, portalEvents = []) {
+		if (portalEvents.includes(event)) return `queue.${constants_default.PORTAL_NAME}`;
+		return `queue.${constants_default.PROJECT_NAME}`;
+	}
+	async publish(eventName, payload, options) {
+		const message = this.getPublishMessage(eventName, payload, options);
+		const routingKey = this.getPublishRoutingKey(eventName);
+		return await this.publishEventToExchange(eventName, message, {
+			...options,
+			routingKey
+		});
+	}
+	async publishDirect(eventName, payload, options = {}) {
+		const { exchangeName: customExchangeName } = options;
+		const exchangeName = customExchangeName ?? this.eventNameToExchangeNameMap.get(eventName);
+		if (!exchangeName) throw new ExternalCommunicatorError(`Exchange name for event ${eventName} is not defined`, HttpStatusCode.INTERNAL_SERVER_ERROR, {
+			event: eventName,
+			customExchangeName
+		}, ErrorType.Unoperated);
+		const routingKey = ExternalEventBus.BuildRequestRoutingKey(eventName);
+		const { data } = this.getPublishMessage(eventName, payload, options);
+		return await this.queueProvider.publishExternalDirect(data, exchangeName, routingKey, options);
+	}
+	getUnicastListeners() {
+		return this.eventCommunicator.getUnicastListeners();
+	}
+	getExchangeNameWithSuffix(topic) {
+		return `${this.exchangePrefixName}${topic}`;
+	}
+	getProducerExchangesOptions() {
+		const [exchangesOptions] = this.defineQueuesAndExchangesOptionsBasedOnGlobalConfig();
+		return exchangesOptions;
+	}
+	getMulticastListeners() {
+		const [exchangesOptions, queuesOptions] = this.defineQueuesAndExchangesOptionsBasedOnGlobalConfig();
+		return this.eventCommunicator.getMulticastListeners(queuesOptions, exchangesOptions, this.eventQueueMap);
+	}
+	getPublishMessage(eventName, message, options) {
+		const { rabbit: { custom: { responseRoutingKeyPrefix } = {} } } = this.queueProvider.getConfig();
+		const responseRoutingKey = this.buildResponseQueueName(eventName, responseRoutingKeyPrefix);
+		const partialMeta = {
+			ignoreCache: options?.ignoreCache,
+			registryApiVersion: options?.registryApiVersion,
+			...this.publishEventsSet.has(eventName) ? { responseRoutingKey } : {}
+		};
+		return new Message(this.getPublishQueueMessageData(eventName, message, partialMeta));
+	}
+	getPublishRoutingKey(eventName) {
+		if (this.publishEventsSet.has(eventName)) return ExternalEventBus.BuildRequestRoutingKey(eventName);
+		else if (this.subscribeEventsSet.has(eventName)) {
+			const { portalEvents } = this.queueProvider.getConfig();
+			return ExternalEventBus.BuildResponseRoutingKey(eventName, portalEvents);
+		}
+		return "";
+	}
+	defineQueuesAndExchangesOptionsBasedOnGlobalConfig() {
+		const { rabbit: { listenerOptions, declareOptions: { assertQueues, assertExchanges, queuesOptions: overriddenQueuesOptions = {} } = {} } } = this.queueProvider.getConfig();
+		const queuesOptions = [];
+		const exchangesMap = /* @__PURE__ */ new Map();
+		for (const [eventName, queueName] of this.eventQueueMap.entries()) {
+			const exchangeName = this.eventNameToExchangeNameMap.get(eventName);
+			if (!exchangeName) {
+				this.logger.error(`Can't find external topic name for event [${eventName}]`);
+				return [[], []];
+			}
+			const queueOptions = {
+				name: queueName,
+				declare: assertQueues,
+				type: QueueTypes.Quorum,
+				options: listenerOptions?.queueOptions,
+				bindTo: [{
+					bind: assertQueues,
+					routingKey: queueName,
+					exchangeName
+				}],
+				consumerOptions: this.optionsBuilder.defineConsumerOptionsBasedOnGlobalConfig(),
+				...overriddenQueuesOptions
+			};
+			queuesOptions.push(queueOptions);
+			const exchangeOptions = {
+				name: exchangeName,
+				type: "topic",
+				declare: assertExchanges
+			};
+			exchangesMap.set(exchangeName, exchangeOptions);
+		}
+		return [[...exchangesMap.values()], queuesOptions];
+	}
+	buildEventQueueMap() {
+		const eventQueueMap = /* @__PURE__ */ new Map();
+		const { service: { publish = [], subscribe = [] }, rabbit: { custom: { responseRoutingKeyPrefix } = {} } } = this.queueProvider.getConfig();
+		if (publish.length === 0 && subscribe.length === 0) {
+			this.logger.info("No one external events to listen");
+			return eventQueueMap;
+		}
+		for (const responseEvent of publish) eventQueueMap.set(responseEvent, this.buildResponseQueueName(responseEvent, responseRoutingKeyPrefix));
+		for (const requestEvent of subscribe) eventQueueMap.set(requestEvent, this.buildRequestQueueName(requestEvent, responseRoutingKeyPrefix));
+		return eventQueueMap;
+	}
+	buildResponseQueueName(eventName, prefix) {
+		const result = `queue.${constants_default.PROJECT_NAME}.${eventName}.res`;
+		if (prefix) return `${prefix}.${result}`;
+		return result;
+	}
+	buildRequestQueueName(eventName, prefix) {
+		const { portalEvents } = this.queueProvider.getConfig();
+		const result = `${ExternalEventBus.prepareQueuePrefix(eventName, portalEvents)}.${eventName}.req`;
+		if (prefix) return `${prefix}.${result}`;
+		return result;
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalEventBus = void 0;
-const errors_1 = require("@diia-inhouse/errors");
-const types_1 = require("@diia-inhouse/types");
-const constants_1 = __importDefault(require("../constants"));
-const interfaces_1 = require("../interfaces");
-const communicator_1 = __importDefault(require("./communicator"));
-const eventCommunicator_1 = require("./eventCommunicator");
-class ExternalEventBus extends communicator_1.default {
-    envService;
-    eventCommunicator;
-    publishEventsSet;
-    subscribeEventsSet;
-    exchangePrefixName = 'TopicExternal';
-    eventQueueMap = new Map();
-    constructor(logger, systemServiceName, envService, queueProvider, externalEventListenerList, eventMessageHandler, hostName) {
-        super(logger, queueProvider, hostName, systemServiceName);
-        this.envService = envService;
-        const { rabbit: { custom }, service: { publish = [], subscribe = [] }, } = this.queueProvider.getConfig();
-        if (custom?.responseRoutingKeyPrefix && !this.envService.isLocal() && !this.envService.isTest()) {
-            throw new Error('Response routing key could be used only on local env');
-        }
-        this.publishEventsSet = new Set(publish);
-        this.subscribeEventsSet = new Set(subscribe);
-        this.eventQueueMap = this.buildEventQueueMap();
-        this.eventCommunicator = new eventCommunicator_1.EventCommunicator(logger, queueProvider, eventMessageHandler, externalEventListenerList);
-    }
-    static BuildRequestRoutingKey(eventName) {
-        return `queue.${constants_1.default.PROJECT_NAME}.${eventName}.req`;
-    }
-    static BuildResponseRoutingKey(eventName, portalEvents = []) {
-        const queuePrefix = ExternalEventBus.prepareQueuePrefix(eventName, portalEvents);
-        return `${queuePrefix}.${eventName}.res`;
-    }
-    static prepareQueuePrefix(event, portalEvents = []) {
-        if (portalEvents.includes(event)) {
-            return `queue.${constants_1.default.PORTAL_NAME}`;
-        }
-        return `queue.${constants_1.default.PROJECT_NAME}`;
-    }
-    async publish(eventName, payload, options) {
-        const message = this.getPublishMessage(eventName, payload, options);
-        const routingKey = this.getPublishRoutingKey(eventName);
-        return await this.publishEventToExchange(eventName, message, { ...options, routingKey });
-    }
-    async publishDirect(eventName, payload, options = {}) {
-        const { exchangeName: customExchangeName } = options;
-        const exchangeName = customExchangeName ?? this.eventNameToExchangeNameMap.get(eventName);
-        if (!exchangeName) {
-            throw new errors_1.ExternalCommunicatorError(`Exchange name for event ${eventName} is not defined`, types_1.HttpStatusCode.INTERNAL_SERVER_ERROR, { event: eventName, customExchangeName }, errors_1.ErrorType.Unoperated);
-        }
-        const routingKey = ExternalEventBus.BuildRequestRoutingKey(eventName);
-        const { data } = this.getPublishMessage(eventName, payload, options);
-        return await this.queueProvider.publishExternalDirect(data, exchangeName, routingKey, options);
-    }
-    getUnicastListeners() {
-        return this.eventCommunicator.getUnicastListeners();
-    }
-    getExchangeNameWithSuffix(topic) {
-        return `${this.exchangePrefixName}${topic}`;
-    }
-    getProducerExchangesOptions() {
-        const [exchangesOptions] = this.defineQueuesAndExchangesOptionsBasedOnGlobalConfig();
-        return exchangesOptions;
-    }
-    getMulticastListeners() {
-        const [exchangesOptions, queuesOptions] = this.defineQueuesAndExchangesOptionsBasedOnGlobalConfig();
-        return this.eventCommunicator.getMulticastListeners(queuesOptions, exchangesOptions, this.eventQueueMap);
-    }
-    getPublishMessage(eventName, message, options) {
-        const { rabbit: { custom: { responseRoutingKeyPrefix } = {} }, } = this.queueProvider.getConfig();
-        const responseRoutingKey = this.buildResponseQueueName(eventName, responseRoutingKeyPrefix);
-        const partialMeta = {
-            ignoreCache: options?.ignoreCache,
-            registryApiVersion: options?.registryApiVersion,
-            ...(this.publishEventsSet.has(eventName) ? { responseRoutingKey } : {}),
-        };
-        const data = this.getPublishQueueMessageData(eventName, message, partialMeta);
-        return new interfaces_1.Message(data);
-    }
-    getPublishRoutingKey(eventName) {
-        if (this.publishEventsSet.has(eventName)) {
-            return ExternalEventBus.BuildRequestRoutingKey(eventName);
-        }
-        else if (this.subscribeEventsSet.has(eventName)) {
-            const { portalEvents } = this.queueProvider.getConfig();
-            return ExternalEventBus.BuildResponseRoutingKey(eventName, portalEvents);
-        }
-        return '';
-    }
-    defineQueuesAndExchangesOptionsBasedOnGlobalConfig() {
-        const { rabbit: { listenerOptions, declareOptions: { assertQueues, assertExchanges, queuesOptions: overriddenQueuesOptions = {} } = {}, }, } = this.queueProvider.getConfig();
-        const queuesOptions = [];
-        const exchangesMap = new Map();
-        for (const [eventName, queueName] of this.eventQueueMap.entries()) {
-            const exchangeName = this.eventNameToExchangeNameMap.get(eventName);
-            if (!exchangeName) {
-                this.logger.error(`Can't find external topic name for event [${eventName}]`);
-                return [[], []];
-            }
-            const queueOptions = {
-                name: queueName,
-                declare: assertQueues,
-                type: interfaces_1.QueueTypes.Quorum,
-                options: listenerOptions?.queueOptions,
-                bindTo: [
-                    {
-                        bind: assertQueues,
-                        routingKey: queueName,
-                        exchangeName: exchangeName,
-                    },
-                ],
-                consumerOptions: this.optionsBuilder.defineConsumerOptionsBasedOnGlobalConfig(),
-                ...overriddenQueuesOptions,
-            };
-            queuesOptions.push(queueOptions);
-            const exchangeOptions = {
-                name: exchangeName,
-                type: interfaces_1.ExchangeType.Topic,
-                declare: assertExchanges,
-            };
-            exchangesMap.set(exchangeName, exchangeOptions);
-        }
-        const exchangesOptions = [...exchangesMap.values()];
-        return [exchangesOptions, queuesOptions];
-    }
-    buildEventQueueMap() {
-        const eventQueueMap = new Map();
-        const { service: { publish = [], subscribe = [] }, rabbit: { custom: { responseRoutingKeyPrefix } = {} }, } = this.queueProvider.getConfig();
-        if (publish.length === 0 && subscribe.length === 0) {
-            this.logger.info('No one external events to listen');
-            return eventQueueMap;
-        }
-        for (const responseEvent of publish) {
-            eventQueueMap.set(responseEvent, this.buildResponseQueueName(responseEvent, responseRoutingKeyPrefix));
-        }
-        for (const requestEvent of subscribe) {
-            eventQueueMap.set(requestEvent, this.buildRequestQueueName(requestEvent, responseRoutingKeyPrefix));
-        }
-        return eventQueueMap;
-    }
-    buildResponseQueueName(eventName, prefix) {
-        const result = `queue.${constants_1.default.PROJECT_NAME}.${eventName}.res`;
-        if (prefix) {
-            return `${prefix}.${result}`;
-        }
-        return result;
-    }
-    buildRequestQueueName(eventName, prefix) {
-        const { portalEvents } = this.queueProvider.getConfig();
-        const result = `${ExternalEventBus.prepareQueuePrefix(eventName, portalEvents)}.${eventName}.req`;
-        if (prefix) {
-            return `${prefix}.${result}`;
-        }
-        return result;
-    }
-}
-exports.ExternalEventBus = ExternalEventBus;
-//# sourceMappingURL=externalEventBus.js.map
+//#endregion
+export { ExternalEventBus };