@diia-inhouse/diia-queue 14.0.20 → 14.0.22

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import { BaseQueueOptions, BindOptions, ConsumerOptions, ExchangeName, ExchangeOptions, ExchangeType, MessageBrokerExternalServiceType, MessageBrokerExternalServiceTypes, MessageBrokerGeneralServiceType, MessageBrokerGeneralServiceTypes, MessageBrokerInternalServiceType, MessageBrokerInternalServiceTypes, MessageBrokerServiceConfig, MessageBrokerServiceType, MessageBrokerServicesConfig, QueueOptions, QueueTypes, RecreateChannelOptions, RedeclareQueueOptions, UnbindOptions, emptyMessageBrokerServiceConfig } from "./interfaces/messageBrokerServiceConfig.js";
+import { ListenerOptions, PublishDirectMessageOptions, PublishDirectOptions, PublishMessageOptions, PublishOptions, PublisherOptions, SubscribeOptions } from "./interfaces/options.js";
 import { AmqpConfig, AmqpConnectionEventNames, ConnectOptions, ConnectionStatus, ReconnectOptions, SocketOptions } from "./interfaces/providers/rabbitmq/amqpConnection.js";
 import { AmqpConnection } from "./providers/rabbitmq/amqpConnection.js";
-import { ListenerOptions, PublishDirectOptions, PublishExternalEventOptions, PublishOptions, PublisherOptions, SubscribeOptions } from "./interfaces/options.js";
 import { EventName, ExternalServiceConfig, InternalServiceConfig, QueueConfigByQueueName, QueueConfigType, QueueName, ServiceConfig, ServiceConfigByConfigType, ServiceRulesConfig, TopicConfig, TopicConfigByConfigType } from "./interfaces/queueConfig/configs.js";
 import { Arguments, ConnectionClientType, ConnectionList, DeclareOptions, ExportConfig, Headers, Message, MessageData, MessageProperties, NackOptions, QueueMessage, QueueMessageData, QueueMessageError, QueueMessageMetaData, RabbitMQConfig, RabbitMQConfigCustomParams, RabbitMQStatus } from "./interfaces/providers/rabbitmq/index.js";
+import { AmqpPublisherPublishOptions, DirectResponse, DirectResponseHeaders, MessageHeaders, MessagePayload, PublishingResult } from "./providers/rabbitmq/amqpPublisher.types.js";
 import { MessageHandler } from "./interfaces/messageHandler.js";
-import { DirectResponse, DirectResponseHeaders, MessageHeaders, MessagePayload, PublishingResult } from "./interfaces/providers/rabbitmq/amqpPublisher.js";
 import { MessageBrokerServicesStatus, QueueConnectionType, QueueStatus, QueueStatusByType } from "./interfaces/queueStatus.js";
 import { QueueContext } from "./interfaces/queueContext.js";
 import { CommunicationDirection, CommunicationsTotalLabelsMap, LabelUnknown, Metrics, TotalListenerChannelErrorsLabelsMap, TotalMessageHandlerErrorsLabelsMap, communicationsTotalLabelsMap } from "./interfaces/metrics/index.js";
@@ -24,4 +24,4 @@ import { Queue } from "./services/queue.js";
 import { ScheduledTask } from "./services/scheduledTask.js";
 import { Task } from "./services/task.js";
 import { CommonQueueDeps, ExternalQueueDeps, InternalQueueDeps, QueueDeps } from "./interfaces/deps.js";
-export { AmqpAsserter, AmqpConfig, AmqpConnection, AmqpConnectionEventNames, AmqpListener, AmqpPublisher, Arguments, BaseQueueOptions, BindOptions, CommonQueueDeps, CommunicationDirection, CommunicationsTotalLabelsMap, ConnectOptions, ConnectionClientType, ConnectionList, ConnectionStatus, ConsumerOptions, DeclareOptions, DirectResponse, DirectResponseHeaders, EventBus, EventBusListener, EventBusQueue, EventListeners, EventMessageHandler, EventMessageValidator, EventName, ExchangeName, ExchangeOptions, ExchangeType, ExportConfig, ExternalCommunicator, ExternalCommunicatorFailureResponse, ExternalCommunicatorResponse, ExternalCommunicatorResponseError, ExternalCommunicatorSuccessResponse, ExternalEventBus, ExternalEventBusQueue, ExternalQueueDeps, ExternalServiceConfig, Headers, InternalQueueConfig, InternalQueueDeps, InternalServiceConfig, LabelUnknown, Listener, ListenerOptions, Message, MessageBrokerExternalServiceType, MessageBrokerExternalServiceTypes, MessageBrokerGeneralServiceType, MessageBrokerGeneralServiceTypes, MessageBrokerInternalServiceType, MessageBrokerInternalServiceTypes, MessageBrokerServiceConfig, MessageBrokerServiceEventsListener, MessageBrokerServiceListener, MessageBrokerServiceType, MessageBrokerServicesConfig, MessageBrokerServicesStatus, MessageData, MessageHandler, MessageHeaders, MessagePayload, MessageProperties, Metrics, NackOptions, PublishDirectOptions, PublishExternalEventOptions, PublishOptions, PublisherOptions, PublishingResult, Queue, QueueConfig, QueueConfigByQueueName, QueueConfigType, QueueConnectionConfig, QueueConnectionType, QueueContext, QueueDeps, QueueMessage, QueueMessageData, QueueMessageError, QueueMessageMetaData, QueueName, QueueOptions, QueueStatus, QueueStatusByType, QueueTypes, RabbitMQConfig, RabbitMQConfigCustomParams, RabbitMQProvider, RabbitMQStatus, ReceiveDirectOps, ReconnectOptions, RecreateChannelOptions, RedeclareQueueOptions, ScheduledTask, ScheduledTasksQueue, ServiceConfig, ServiceConfigByConfigType, ServiceRulesConfig, SocketOptions, SubscribeOptions, Task, TaskListener, TaskQueue, TopicConfig, TopicConfigByConfigType, TotalListenerChannelErrorsLabelsMap, TotalMessageHandlerErrorsLabelsMap, UnbindOptions, communicationsTotalLabelsMap, emptyMessageBrokerServiceConfig };
+export { AmqpAsserter, AmqpConfig, AmqpConnection, AmqpConnectionEventNames, AmqpListener, AmqpPublisher, AmqpPublisherPublishOptions, Arguments, BaseQueueOptions, BindOptions, CommonQueueDeps, CommunicationDirection, CommunicationsTotalLabelsMap, ConnectOptions, ConnectionClientType, ConnectionList, ConnectionStatus, ConsumerOptions, DeclareOptions, DirectResponse, DirectResponseHeaders, EventBus, EventBusListener, EventBusQueue, EventListeners, EventMessageHandler, EventMessageValidator, EventName, ExchangeName, ExchangeOptions, ExchangeType, ExportConfig, ExternalCommunicator, ExternalCommunicatorFailureResponse, ExternalCommunicatorResponse, ExternalCommunicatorResponseError, ExternalCommunicatorSuccessResponse, ExternalEventBus, ExternalEventBusQueue, ExternalQueueDeps, ExternalServiceConfig, Headers, InternalQueueConfig, InternalQueueDeps, InternalServiceConfig, LabelUnknown, Listener, ListenerOptions, Message, MessageBrokerExternalServiceType, MessageBrokerExternalServiceTypes, MessageBrokerGeneralServiceType, MessageBrokerGeneralServiceTypes, MessageBrokerInternalServiceType, MessageBrokerInternalServiceTypes, MessageBrokerServiceConfig, MessageBrokerServiceEventsListener, MessageBrokerServiceListener, MessageBrokerServiceType, MessageBrokerServicesConfig, MessageBrokerServicesStatus, MessageData, MessageHandler, MessageHeaders, MessagePayload, MessageProperties, Metrics, NackOptions, PublishDirectMessageOptions, PublishDirectOptions, PublishMessageOptions, PublishOptions, PublisherOptions, PublishingResult, Queue, QueueConfig, QueueConfigByQueueName, QueueConfigType, QueueConnectionConfig, QueueConnectionType, QueueContext, QueueDeps, QueueMessage, QueueMessageData, QueueMessageError, QueueMessageMetaData, QueueName, QueueOptions, QueueStatus, QueueStatusByType, QueueTypes, RabbitMQConfig, RabbitMQConfigCustomParams, RabbitMQProvider, RabbitMQStatus, ReceiveDirectOps, ReconnectOptions, RecreateChannelOptions, RedeclareQueueOptions, ScheduledTask, ScheduledTasksQueue, ServiceConfig, ServiceConfigByConfigType, ServiceRulesConfig, SocketOptions, SubscribeOptions, Task, TaskListener, TaskQueue, TopicConfig, TopicConfigByConfigType, TotalListenerChannelErrorsLabelsMap, TotalMessageHandlerErrorsLabelsMap, UnbindOptions, communicationsTotalLabelsMap, emptyMessageBrokerServiceConfig };

package/dist/interfaces/externalCommunicator.d.ts

@@ -37,6 +37,11 @@ interface ReceiveDirectOps {
   * Defaults to a freshly generated `randomUUID()` when omitted.
   */
   requestUuid?: string;
+  /**
+  * Timeout (ms) for publish drain / backpressure wait
+  * @default 10000
+  */
+  publishTimeout?: number;
 }
 interface ExternalCommunicatorResponseError {
   http_code: HttpStatusCode;

package/dist/interfaces/index.d.ts

@@ -1,10 +1,10 @@
 import { BaseQueueOptions, BindOptions, ConsumerOptions, ExchangeName, ExchangeOptions, ExchangeType, MessageBrokerExternalServiceType, MessageBrokerExternalServiceTypes, MessageBrokerGeneralServiceType, MessageBrokerGeneralServiceTypes, MessageBrokerInternalServiceType, MessageBrokerInternalServiceTypes, MessageBrokerServiceConfig, MessageBrokerServiceType, MessageBrokerServicesConfig, QueueOptions, QueueTypes, RecreateChannelOptions, RedeclareQueueOptions, UnbindOptions, emptyMessageBrokerServiceConfig } from "./messageBrokerServiceConfig.js";
+import { ListenerOptions, PublishDirectMessageOptions, PublishDirectOptions, PublishMessageOptions, PublishOptions, PublisherOptions, SubscribeOptions } from "./options.js";
 import { AmqpConfig, AmqpConnectionEventNames, ConnectOptions, ConnectionStatus, ReconnectOptions, SocketOptions } from "./providers/rabbitmq/amqpConnection.js";
-import { ListenerOptions, PublishDirectOptions, PublishExternalEventOptions, PublishOptions, PublisherOptions, SubscribeOptions } from "./options.js";
 import { EventName, ExternalServiceConfig, InternalServiceConfig, QueueConfigByQueueName, QueueConfigType, QueueName, ServiceConfig, ServiceConfigByConfigType, ServiceRulesConfig, TopicConfig, TopicConfigByConfigType } from "./queueConfig/configs.js";
 import { Arguments, ConnectionClientType, ConnectionList, DeclareOptions, ExportConfig, Headers, Message, MessageData, MessageProperties, NackOptions, QueueMessage, QueueMessageData, QueueMessageError, QueueMessageMetaData, RabbitMQConfig, RabbitMQConfigCustomParams, RabbitMQStatus } from "./providers/rabbitmq/index.js";
+import { AmqpPublisherPublishOptions, DirectResponse, DirectResponseHeaders, MessageHeaders, MessagePayload, PublishingResult } from "../providers/rabbitmq/amqpPublisher.types.js";
 import { MessageHandler } from "./messageHandler.js";
-import { DirectResponse, DirectResponseHeaders, MessageHeaders, MessagePayload, PublishingResult } from "./providers/rabbitmq/amqpPublisher.js";
 import { MessageBrokerServicesStatus, QueueConnectionType, QueueStatus, QueueStatusByType } from "./queueStatus.js";
 import { QueueContext } from "./queueContext.js";
 import { CommunicationDirection, CommunicationsTotalLabelsMap, LabelUnknown, Metrics, TotalListenerChannelErrorsLabelsMap, TotalMessageHandlerErrorsLabelsMap, communicationsTotalLabelsMap } from "./metrics/index.js";
@@ -44,7 +44,7 @@ interface ExternalEventBusQueue {
   * - use the publishToExchange method for pushing a message by a routing key
   * - use the publishToQueue method for pushing a message to a queue
   * */
-  publish(eventName: EventName, message: MessagePayload, options?: PublishExternalEventOptions): Promise<PublishingResult>;
+  publish(eventName: EventName, message: MessagePayload, options?: PublishOptions): Promise<PublishingResult>;
   publishDirect<T>(eventName: string, message: MessagePayload, options?: PublishDirectOptions): Promise<T>;
   publishToExchange(exchangeName: ExchangeName, routingKey: string, messageData: MessageData, options?: PublishOptions): Promise<PublishingResult>;
   publishToQueue(queueName: QueueName, messageData: MessageData): Promise<PublishingResult>;

package/dist/interfaces/options.d.ts

@@ -3,24 +3,90 @@ import { Options } from "amqplib";
 
 //#region src/interfaces/options.d.ts
 interface PublisherOptions {
+  /**
+  * @deprecated use directResponseTimeout instead. Applies to RPC direct response wait only, not publish drain.
+  */
   timeout?: number;
+  /**
+  * Timeout (ms) for publish drain / backpressure wait
+  * @default 10000
+  */
+  publishTimeout?: number;
+  /**
+  * Reply-to queue name for RPC direct responses
+  * @default amq.rabbitmq.reply-to
+  */
   replyToQueueName?: string;
+  /**
+  * Timeout (ms) for direct response
+  * @default 10000
+  */
+  directResponseTimeout?: number;
 }
 interface ListenerOptions {
   queueOptions?: Options.AssertQueue;
   prefetchCount?: number;
   recreateChannelOptions?: RecreateChannelOptions;
 }
+interface PublishMessageOptions {
+  /**
+  * How to handle publish drain / backpressure wait timeout:
+  * - `true` — reject with `InternalServerError` (`Message publish timeout exceeded`)
+  * - `false` — log the error, resolve, and record publish metrics with `ErrorType.Unoperated`
+  * @default true
+  */
+  throwOnPublishTimeout?: boolean;
+  /**
+  * Timeout (ms) for publish drain / backpressure wait
+  * @default 10000
+  */
+  publishTimeout?: number;
+}
+interface PublishDirectMessageOptions {
+  /**
+  * Timeout (ms) for direct response
+  * @default 10000
+  */
+  responseTimeout?: number;
+  /**
+  * Timeout (ms) for publish drain / backpressure wait
+  * @default 10000
+  */
+  publishTimeout?: number;
+}
 interface PublishDirectOptions {
+  /**
+  * Override the target exchange. Defaults to the exchange resolved from the
+  * external queue configuration for the given event.
+  * @default undefined
+  */
   exchangeName?: string;
+  /**
+  * Timeout (ms) for direct response
+  * @default 10000
+  */
   timeout?: number;
+  /**
+  * Whether to ignore cache
+  * @default false
+  */
   ignoreCache?: boolean;
+  /**
+  * Registry API version
+  * @default undefined
+  */
   registryApiVersion?: string;
+  /**
+  * Timeout (ms) for publish drain / backpressure wait
+  * @default 10000
+  */
+  publishTimeout?: number;
 }
-interface PublishOptions {
+interface PublishOptions extends PublishMessageOptions {
   /**
   * Delay (ms) before message delivery
   * @default undefined
+  * @deprecated rabbitmq version 4.x does not support delays
   */
   delay?: number;
   /**
@@ -28,16 +94,6 @@ interface PublishOptions {
   * @default undefined
   */
   routingKey?: string;
-  /**
-  * Timeout (ms) for publish operation
-  * @default Infinity
-  */
-  publishTimeout?: number;
-  /**
-  * Whether to throw error on timeout (true) or return false (false)
-  * @default true
-  */
-  throwOnPublishTimeout?: boolean;
 }
 interface SubscribeOptions {
   routingKey?: string;
@@ -47,6 +103,5 @@ interface SubscribeOptions {
   */
   delayed?: boolean;
 }
-interface PublishExternalEventOptions extends PublishOptions, PublishDirectOptions {}
 //#endregion
-export { ListenerOptions, PublishDirectOptions, PublishExternalEventOptions, PublishOptions, PublisherOptions, SubscribeOptions };
+export { ListenerOptions, PublishDirectMessageOptions, PublishDirectOptions, PublishMessageOptions, PublishOptions, PublisherOptions, SubscribeOptions };

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

@@ -1,7 +1,7 @@
 import { BaseQueueOptions } from "../../messageBrokerServiceConfig.js";
+import { ListenerOptions } from "../../options.js";
 import { ConnectOptions, ConnectionStatus, ReconnectOptions, SocketOptions } from "./amqpConnection.js";
 import { AmqpConnection } from "../../../providers/rabbitmq/amqpConnection.js";
-import { ListenerOptions } from "../../options.js";
 import { EventName, QueueConfigByQueueName, ServiceConfigByConfigType, TopicConfigByConfigType } from "../../queueConfig/configs.js";
 import { ErrorData } from "@diia-inhouse/errors";
 import * as amqp from "amqplib";

package/dist/providers/index.d.ts

@@ -1,4 +1,5 @@
 import { AmqpConnection } from "./rabbitmq/amqpConnection.js";
+import { AmqpPublisherPublishOptions, DirectResponse, DirectResponseHeaders, MessageHeaders, MessagePayload, PublishingResult } from "./rabbitmq/amqpPublisher.types.js";
 import { AmqpAsserter } from "./rabbitmq/amqpAsserter.js";
 import { AmqpListener } from "./rabbitmq/amqpListener.js";
 import { AmqpPublisher } from "./rabbitmq/amqpPublisher.js";

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

@@ -1,9 +1,9 @@
 import { ExchangeName } from "../../interfaces/messageBrokerServiceConfig.js";
+import { PublishDirectMessageOptions, PublishMessageOptions, PublisherOptions } from "../../interfaces/options.js";
 import { ConnectionStatus } from "../../interfaces/providers/rabbitmq/amqpConnection.js";
 import { AmqpConnection } from "./amqpConnection.js";
-import { PublisherOptions } from "../../interfaces/options.js";
 import { QueueMessageData } from "../../interfaces/providers/rabbitmq/index.js";
-import { MessageHeaders, PublishingResult } from "../../interfaces/providers/rabbitmq/amqpPublisher.js";
+import { MessageHeaders, PublishingResult } from "./amqpPublisher.types.js";
 import { RabbitMQMetricsService } from "../../services/metrics.js";
 import { Logger } from "@diia-inhouse/types";
 
@@ -19,10 +19,12 @@ declare class AmqpPublisher {
   private readonly replyToQueueName;
   private eventEmitter?;
   private readonly directResponseTimeout;
+  private readonly publishTimeout;
+  private readonly throwOnPublishTimeout;
   constructor(connection: AmqpConnection, logger: Logger, rabbitMQMetrics: RabbitMQMetricsService, systemServiceName: string, options?: PublisherOptions);
   init(): Promise<void>;
-  publishToExchange(exchangeName: ExchangeName, message: QueueMessageData, headers: MessageHeaders, routingKey?: string): Promise<PublishingResult>;
-  publishToExchangeDirect<T>(exchangeName: ExchangeName, message: QueueMessageData, headers: MessageHeaders, routingKey?: string, responseTimeoutMs?: number): Promise<T>;
+  publishToExchange(exchangeName: ExchangeName, message: QueueMessageData, headers: MessageHeaders, routingKey?: string, publishMessageOptions?: PublishMessageOptions): Promise<PublishingResult>;
+  publishToExchangeDirect<T>(exchangeName: ExchangeName, message: QueueMessageData, headers: MessageHeaders, routingKey?: string, publishDirectOptions?: PublishDirectMessageOptions): Promise<T>;
   getStatus(): ConnectionStatus;
   private createRegularChannel;
   private createRpcChannel;
@@ -30,7 +32,9 @@ declare class AmqpPublisher {
   private publishMessage;
   private publishRequest;
   private publish;
-  private getPublishOptions;
+  private waitForDrain;
+  private getWaitingTimeMs;
+  private getAmqpPublisherPublishOptions;
   private receiveDirectResponse;
   private collectMetrics;
 }

package/dist/providers/rabbitmq/amqpPublisher.js

@@ -24,13 +24,16 @@ var AmqpPublisher = class {
 	replyToQueueName = REPLY_TO_QUEUE_NAME;
 	eventEmitter;
 	directResponseTimeout = 1e4;
+	publishTimeout = 1e4;
+	throwOnPublishTimeout = true;
 	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;
+		this.publishTimeout = options.publishTimeout ?? this.publishTimeout;
+		this.directResponseTimeout = options.directResponseTimeout ?? options.timeout ?? this.directResponseTimeout;
+		this.replyToQueueName = options.replyToQueueName ?? REPLY_TO_QUEUE_NAME;
 	}
 	async init() {
 		await this.createRpcChannel();
@@ -40,7 +43,7 @@ var AmqpPublisher = class {
 			await this.createRegularChannel();
 		});
 	}
-	async publishToExchange(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY) {
+	async publishToExchange(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY, publishMessageOptions = {}) {
 		const { event, payload } = message;
 		const startTime = process.hrtime.bigint();
 		const route = event;
@@ -52,14 +55,14 @@ var AmqpPublisher = class {
 				this.logger.error(errorMessage);
 				throw new InternalServerError(errorMessage);
 			}
-			const publishOptions = this.getPublishOptions(headers);
+			const amqpPublisherPublishOptions = this.getAmqpPublisherPublishOptions(publishMessageOptions, 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);
+			const isPublished = await this.publishMessage(message, exchangeName, routingKey, amqpPublisherPublishOptions);
+			this.collectMetrics(startTime, route, source, destination, isPublished ? void 0 : ErrorType.Unoperated);
 		} catch (err) {
 			this.logger.error("Error while publishing event", {
 				err,
@@ -70,15 +73,15 @@ var AmqpPublisher = class {
 			throw err;
 		}
 	}
-	async publishToExchangeDirect(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY, responseTimeoutMs = this.directResponseTimeout) {
+	async publishToExchangeDirect(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY, publishDirectOptions = {}) {
 		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;
+			const { body, headers: { [Headers.handledBy]: handledBy } } = await this.receiveDirectResponse(exchangeName, message, headers, routingKey, publishDirectOptions);
+			destination = handledBy ?? destination;
 			return body;
 		} catch (err) {
 			this.logger.error("Failed to receive a direct response", {
@@ -110,71 +113,140 @@ var AmqpPublisher = class {
 			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
-		});
+		const response = {
+			body: JSON.parse(msg.content.toString("utf8")),
+			headers: msg.properties.headers || {}
+		};
+		this.eventEmitter?.emit(msg.properties.correlationId, response);
 	}
-	publishMessage(eventMessage, exchangeName, routingKey, publishOptions) {
+	async publishMessage(eventMessage, exchangeName, routingKey, amqpPublisherPublishOptions) {
 		if (!this.regularChannel) throw new Error("Publishing message is denied, channel is not initialized");
-		return this.publish(eventMessage, exchangeName, routingKey, publishOptions, this.regularChannel);
+		return await this.publish(eventMessage, exchangeName, routingKey, amqpPublisherPublishOptions, this.regularChannel);
 	}
-	publishRequest(eventMessage, exchangeName, routingKey, publishOptions) {
+	async publishRequest(eventMessage, exchangeName, routingKey, amqpPublisherPublishOptions) {
 		if (!this.rpcChannel) throw new Error("Publishing RPC request is denied, channel is not initialized");
-		return this.publish(eventMessage, exchangeName, routingKey, publishOptions, this.rpcChannel);
+		await this.publish(eventMessage, exchangeName, routingKey, amqpPublisherPublishOptions, 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");
+	async publish(eventMessage, exchangeName, routingKey, publishOptions, channel) {
+		const { channel: channelPublishOptions, custom: customPublishOptions } = publishOptions;
+		const content = Buffer.from(JSON.stringify(eventMessage));
+		if (channel.publish(exchangeName, routingKey, content, channelPublishOptions)) return true;
+		const backpressureStartTime = process.hrtime.bigint();
+		const logParams = {
+			routingKey,
+			exchangeName,
+			event: eventMessage.event
+		};
+		try {
+			const hasMessagePublished = await this.waitForDrain(channel, customPublishOptions);
+			const waitTimeMs = this.getWaitingTimeMs(backpressureStartTime);
+			if (hasMessagePublished) this.logger.info("Message published after backpressure", {
+				...logParams,
+				waitTimeMs
+			});
+			else this.logger.error("Message publish timeout exceeded", {
+				...logParams,
+				waitTimeMs
+			});
+			return hasMessagePublished;
+		} catch (err) {
+			const waitTimeMs = this.getWaitingTimeMs(backpressureStartTime);
+			this.logger.error("Error while waiting for drain", {
+				err,
+				...logParams,
+				waitTimeMs
+			});
+			throw err;
+		}
 	}
-	getPublishOptions(headers, extraOpts = {}) {
+	async waitForDrain(channel, publishMessageOptions) {
+		const { publishTimeout = this.publishTimeout, throwOnPublishTimeout = this.throwOnPublishTimeout } = publishMessageOptions;
+		const { promise, resolve, reject } = Promise.withResolvers();
+		let timeoutId;
+		const cleanup = () => {
+			channel.off("drain", onDrain);
+			channel.off("error", onError);
+			clearTimeout(timeoutId);
+		};
+		const onDrain = () => {
+			resolve(true);
+		};
+		const onError = (err) => {
+			reject(err);
+		};
+		channel.once("drain", onDrain);
+		channel.once("error", onError);
+		timeoutId = setTimeout(() => {
+			if (throwOnPublishTimeout) reject(new InternalServerError("Message publish timeout exceeded"));
+			else resolve(false);
+		}, publishTimeout);
+		try {
+			return await promise;
+		} finally {
+			cleanup();
+		}
+	}
+	getWaitingTimeMs(backpressureStartTime) {
+		return Number(process.hrtime.bigint() - backpressureStartTime) / 1e6;
+	}
+	getAmqpPublisherPublishOptions(customOptions, headers, amqpOptions = {}) {
 		return {
-			...this.defaultPublishOptions,
-			timestamp: Date.now(),
-			...extraOpts,
-			headers: {
-				...headers,
-				[Headers.sentFrom]: this.systemServiceName
-			}
+			channel: {
+				...this.defaultPublishOptions,
+				timestamp: Date.now(),
+				...amqpOptions,
+				headers: {
+					...headers,
+					[Headers.sentFrom]: this.systemServiceName
+				}
+			},
+			custom: { ...customOptions }
 		};
 	}
-	async receiveDirectResponse(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY, responseTimeoutMs = this.directResponseTimeout) {
+	async receiveDirectResponse(exchangeName, message, headers, routingKey = DEFAULT_ROUTING_KEY, publishDirectOptions) {
 		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, {
+		const publishMessageOptions = {
+			...publishDirectOptions,
+			throwOnPublishTimeout: true
+		};
+		const amqpPublishOptions = {
 			correlationId,
 			replyTo: this.replyToQueueName
-		});
+		};
+		const amqpPublisherPublishOptions = this.getAmqpPublisherPublishOptions(publishMessageOptions, headers, amqpPublishOptions);
 		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);
+		const { promise, resolve, reject } = Promise.withResolvers();
+		let timeoutId;
+		const cleanup = () => {
+			clearTimeout(timeoutId);
+			this.eventEmitter?.removeAllListeners(correlationId);
+		};
+		const onResponse = (args) => {
+			this.logger.info(`Received direct event response: ${event}`, { traceId: headers.traceId });
+			this.logger.io(`Direct event response message`, {
+				body: args.body,
+				traceId: headers.traceId
 			});
-			try {
-				this.publishRequest(message, exchangeName, routingKey, publishOptions);
-			} catch (err) {
-				reject(err);
-			}
-		});
+			resolve(args);
+		};
+		this.eventEmitter?.once(correlationId, onResponse);
+		try {
+			await this.publishRequest(message, exchangeName, routingKey, amqpPublisherPublishOptions);
+			const responseTimeout = publishDirectOptions.responseTimeout ?? this.directResponseTimeout;
+			timeoutId = setTimeout(() => {
+				reject(new ExternalCommunicatorError(`Time out for external event: ${event}`, HttpStatusCode.GATEWAY_TIMEOUT));
+			}, responseTimeout);
+			return await promise;
+		} finally {
+			cleanup();
+		}
 	}
 	collectMetrics(startTime, route, source, destination, errorType) {
 		this.rabbitMQMetrics.collectCommunicationsTotalMetric(route, source, destination, "outbound");

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

@@ -0,0 +1,25 @@
+import { PublishMessageOptions } from "../../interfaces/options.js";
+import { Headers } from "../../interfaces/providers/rabbitmq/index.js";
+import { MessagePropertyHeaders, Options } from "amqplib";
+
+//#region src/providers/rabbitmq/amqpPublisher.types.d.ts
+type MessagePayload = unknown;
+interface MessageHeaders {
+  traceId: string;
+  serviceCode?: string;
+  "x-delay"?: number;
+}
+type DirectResponseHeaders = MessagePropertyHeaders & {
+  [Headers.handledBy]?: string;
+};
+interface DirectResponse<T = unknown> {
+  body: T;
+  headers: DirectResponseHeaders;
+}
+type PublishingResult = void;
+interface AmqpPublisherPublishOptions {
+  channel: Options.Publish;
+  custom: PublishMessageOptions;
+}
+//#endregion
+export { AmqpPublisherPublishOptions, DirectResponse, DirectResponseHeaders, MessageHeaders, MessagePayload, PublishingResult };

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

@@ -1,10 +1,10 @@
 import { MessageBrokerServiceConfig, QueueOptions } from "../../interfaces/messageBrokerServiceConfig.js";
+import { PublishDirectMessageOptions, PublishOptions } from "../../interfaces/options.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 { PublishingResult } from "./amqpPublisher.types.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";
@@ -31,6 +31,9 @@ declare class RabbitMQProvider extends EventEmitter {
   private publisher?;
   private asserter?;
   private connectionList;
+  private readonly publishTimeout;
+  private readonly directResponseTimeout;
+  private readonly throwOnPublishTimeout;
   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);
@@ -40,7 +43,7 @@ declare class RabbitMQProvider extends EventEmitter {
   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>;
+  publishExternalDirect<T>(message: QueueMessageData, exchangeName: string, routingKey?: string, options?: PublishDirectMessageOptions): Promise<T>;
   getStatus(): RabbitMQStatus;
   makeAMQPConnection(client: ConnectionClientType): Promise<AmqpConnection>;
   makeAMQPListener(queuesOptions: QueueOptions[]): Promise<AmqpListener>;

package/dist/providers/rabbitmq/index.js

@@ -8,11 +8,9 @@ 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 _ from "lodash";
+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;
@@ -34,6 +32,9 @@ var RabbitMQProvider = class extends EventEmitter {
 		["asserter"]: {},
 		["publisher"]: {}
 	};
+	publishTimeout = 1e4;
+	directResponseTimeout = 1e4;
+	throwOnPublishTimeout = true;
 	publisherIsNotInitializedErrorMsg = "Publisher is not initialized";
 	rabbitMQMetricsService;
 	constructor(systemServiceName, rabbitmqConfig, serviceConfig, topicsConfig, portalEvents, logger, metrics, asyncLocalStorage = void 0, queuesConfig = void 0, messageBrokerServiceConfig = void 0) {
@@ -86,23 +87,23 @@ var RabbitMQProvider = class extends EventEmitter {
 		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);
+		const { delay, publishTimeout = this.publishTimeout, throwOnPublishTimeout = this.throwOnPublishTimeout } = options || {};
+		const headers = this.preparePublisherHeaders(delay);
+		if (!this.publisher) throw new Error(this.publisherIsNotInitializedErrorMsg);
+		return await this.publisher.publishToExchange(exchangeName, message, headers, routingKey, {
+			...options,
+			publishTimeout,
+			throwOnPublishTimeout
 		});
 	}
 	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);
+		const { publishTimeout = this.publishTimeout } = options || {};
+		return await this.publisher.publishToExchangeDirect(exchangeName, message, headers, routingKey, {
+			...options,
+			publishTimeout
+		});
 	}
 	getStatus() {
 		return {
@@ -111,7 +112,7 @@ var RabbitMQProvider = class extends EventEmitter {
 		};
 	}
 	async makeAMQPConnection(client) {
-		return new AmqpConnection(this.rabbitmqConfig.connection, this.logger, this.rabbitmqConfig.reconnectOptions, _.merge({ clientProperties: { connectionClientType: client } }, this.rabbitmqConfig.socketOptions));
+		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);
@@ -120,7 +121,10 @@ var RabbitMQProvider = class extends EventEmitter {
 		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);
+		return new AmqpPublisher(await this.getConnection("publisher"), this.logger, this.rabbitMQMetricsService, this.systemServiceName, {
+			publishTimeout: this.publishTimeout,
+			directResponseTimeout: this.directResponseTimeout
+		});
 	}
 	async setListener(queuesOptions) {
 		if (!this.listener) {

package/dist/services/communicator.d.ts

@@ -2,8 +2,8 @@ import { ExchangeName, ExchangeOptions, MessageBrokerServiceConfig } from "../in
 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 { MessagePayload, PublishingResult } from "../providers/rabbitmq/amqpPublisher.types.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";

package/dist/services/eventBus.d.ts

@@ -1,7 +1,7 @@
 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 { MessagePayload, PublishingResult } from "../providers/rabbitmq/amqpPublisher.types.js";
 import { EventBusListener, EventBusQueue, MessageBrokerServiceEventsListener } from "../interfaces/index.js";
 import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
 import { Communicator } from "./communicator.js";

package/dist/services/eventCommunicator.js

@@ -1,5 +1,5 @@
 import { collectEventBusListeners } from "../utils.js";
-import _ from "lodash";
+import lodash from "lodash";
 //#region src/services/eventCommunicator.ts
 var EventCommunicator = class {
 	logger;
@@ -31,8 +31,8 @@ var EventCommunicator = class {
 	getUnicastListeners() {
 		const listeners = [];
 		const { queuesOptions, exchangesOptions } = this.queueProvider.getMessageBrokerServiceConfig();
-		const queuesOptionsMap = _.keyBy(queuesOptions, "name");
-		const exchangesOptionsMap = _.keyBy(exchangesOptions, "name");
+		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) {

package/dist/services/externalCommunicator.js

@@ -110,7 +110,7 @@ var ExternalCommunicator = class {
 	* ```
 	*/
 	async receiveDirect(event, request = {}, ops) {
-		const { exchangeName, validationRules, ignoreCache, timeout, registryApiVersion, requestUuid = randomUUID() } = ops;
+		const { exchangeName, publishTimeout, validationRules, ignoreCache, timeout, registryApiVersion, requestUuid = randomUUID() } = ops;
 		const payload = {
 			uuid: requestUuid,
 			request
@@ -119,7 +119,8 @@ var ExternalCommunicator = class {
 			ignoreCache,
 			timeout,
 			exchangeName,
-			registryApiVersion
+			registryApiVersion,
+			publishTimeout
 		};
 		const externalResponse = await this.externalEventBus.publishDirect(event, payload, options);
 		this.logger.debug("External direct response", externalResponse);

package/dist/services/externalEventBus.d.ts

@@ -1,7 +1,7 @@
 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 { MessagePayload, PublishingResult } from "../providers/rabbitmq/amqpPublisher.types.js";
 import { EventBusListener, ExternalEventBusQueue, MessageBrokerServiceEventsListener } from "../interfaces/index.js";
 import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
 import { Communicator } from "./communicator.js";
@@ -29,6 +29,7 @@ declare class ExternalEventBus extends Communicator implements ExternalEventBusQ
   protected getProducerExchangesOptions(): ExchangeOptions[];
   protected override getMulticastListeners(): MessageBrokerServiceEventsListener[];
   private getPublishMessage;
+  private getPublishDirectMessage;
   private getPublishRoutingKey;
   private defineQueuesAndExchangesOptionsBasedOnGlobalConfig;
   private buildEventQueueMap;

package/dist/services/externalEventBus.js

@@ -35,7 +35,7 @@ var ExternalEventBus = class ExternalEventBus extends Communicator {
 		return `queue.${constants_default.PROJECT_NAME}`;
 	}
 	async publish(eventName, payload, options) {
-		const message = this.getPublishMessage(eventName, payload, options);
+		const message = this.getPublishMessage(eventName, payload);
 		const routingKey = this.getPublishRoutingKey(eventName);
 		return await this.publishEventToExchange(eventName, message, {
 			...options,
@@ -50,8 +50,12 @@ var ExternalEventBus = class ExternalEventBus extends Communicator {
 			customExchangeName
 		}, ErrorType.Unoperated);
 		const routingKey = ExternalEventBus.BuildRequestRoutingKey(eventName);
-		const { data } = this.getPublishMessage(eventName, payload, options);
-		return await this.queueProvider.publishExternalDirect(data, exchangeName, routingKey, options);
+		const { data } = this.getPublishDirectMessage(eventName, payload, options);
+		const publishDirectMessageOptions = {
+			responseTimeout: options.timeout,
+			publishTimeout: options.publishTimeout
+		};
+		return await this.queueProvider.publishExternalDirect(data, exchangeName, routingKey, publishDirectMessageOptions);
 	}
 	getUnicastListeners() {
 		return this.eventCommunicator.getUnicastListeners();
@@ -67,7 +71,13 @@ var ExternalEventBus = class ExternalEventBus extends Communicator {
 		const [exchangesOptions, queuesOptions] = this.defineQueuesAndExchangesOptionsBasedOnGlobalConfig();
 		return this.eventCommunicator.getMulticastListeners(queuesOptions, exchangesOptions, this.eventQueueMap);
 	}
-	getPublishMessage(eventName, message, options) {
+	getPublishMessage(eventName, message) {
+		const { rabbit: { custom: { responseRoutingKeyPrefix } = {} } } = this.queueProvider.getConfig();
+		const responseRoutingKey = this.buildResponseQueueName(eventName, responseRoutingKeyPrefix);
+		const partialMeta = this.publishEventsSet.has(eventName) ? { responseRoutingKey } : {};
+		return new Message(this.getPublishQueueMessageData(eventName, message, partialMeta));
+	}
+	getPublishDirectMessage(eventName, message, options) {
 		const { rabbit: { custom: { responseRoutingKeyPrefix } = {} } } = this.queueProvider.getConfig();
 		const responseRoutingKey = this.buildResponseQueueName(eventName, responseRoutingKeyPrefix);
 		const partialMeta = {

package/dist/services/scheduledTask.d.ts

@@ -1,6 +1,6 @@
 import { ExchangeName, ExchangeOptions } from "../interfaces/messageBrokerServiceConfig.js";
 import { QueueName } from "../interfaces/queueConfig/configs.js";
-import { PublishingResult } from "../interfaces/providers/rabbitmq/amqpPublisher.js";
+import { PublishingResult } from "../providers/rabbitmq/amqpPublisher.types.js";
 import { EventBusListener, MessageBrokerServiceEventsListener, ScheduledTasksQueue } from "../interfaces/index.js";
 import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
 import { Communicator } from "./communicator.js";

package/dist/services/task.d.ts

@@ -1,5 +1,5 @@
 import { ExchangeOptions } from "../interfaces/messageBrokerServiceConfig.js";
-import { MessagePayload, PublishingResult } from "../interfaces/providers/rabbitmq/amqpPublisher.js";
+import { MessagePayload, PublishingResult } from "../providers/rabbitmq/amqpPublisher.types.js";
 import { MessageBrokerServiceListener, TaskListener, TaskQueue } from "../interfaces/index.js";
 import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
 import { Communicator } from "./communicator.js";

package/dist/services/task.js

@@ -2,7 +2,7 @@ import { QueueTypes } from "../interfaces/messageBrokerServiceConfig.js";
 import "../interfaces/index.js";
 import constants_default from "../constants.js";
 import Communicator from "./communicator.js";
-import _ from "lodash";
+import lodash from "lodash";
 //#region src/services/task.ts
 var Task = class extends Communicator {
 	serviceName;
@@ -18,8 +18,8 @@ var Task = class extends Communicator {
 	}
 	async onInit() {
 		const { queuesOptions, exchangesOptions } = await this.init();
-		const queuesOptionsMap = _.keyBy(queuesOptions, "name");
-		const exchangesOptionsMap = _.keyBy(exchangesOptions, "name");
+		const queuesOptionsMap = lodash.keyBy(queuesOptions, "name");
+		const exchangesOptionsMap = lodash.keyBy(exchangesOptions, "name");
 		for (const task of this.taskList) {
 			const { name: taskName, isDelayed = false, queueNames = [] } = task;
 			if (queueNames.length === 0) {
@@ -69,8 +69,8 @@ var Task = class extends Communicator {
 	getUnicastListeners() {
 		const listeners = [];
 		const { queuesOptions, exchangesOptions } = this.queueProvider.getMessageBrokerServiceConfig();
-		const queuesOptionsMap = _.keyBy(queuesOptions, "name");
-		const exchangesOptionsMap = _.keyBy(exchangesOptions, "name");
+		const queuesOptionsMap = lodash.keyBy(queuesOptions, "name");
+		const exchangesOptionsMap = lodash.keyBy(exchangesOptions, "name");
 		for (const task of this.taskList) {
 			const { queueNames = [], name: taskName, isDelayed = false } = task;
 			if (queueNames.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@diia-inhouse/diia-queue",
-    "version": "14.0.20",
+    "version": "14.0.22",
     "type": "module",
     "description": "Package provide queue functionality",
     "main": "dist/index.js",
@@ -37,8 +37,7 @@
     "dependencies": {
         "@types/amqplib": "0.10.8",
         "amqplib": "0.10.9",
-        "lodash": "4.18.1",
-        "p-timeout": "4.1.0"
+        "lodash": "4.18.1"
     },
     "peerDependencies": {
         "@diia-inhouse/diia-logger": ">=4.0.0",
@@ -52,15 +51,15 @@
     },
     "devDependencies": {
         "@diia-inhouse/configs": "7.0.1",
-        "@diia-inhouse/diia-logger": "4.3.12",
+        "@diia-inhouse/diia-logger": "4.3.13",
         "@diia-inhouse/diia-metrics": "7.1.23",
-        "@diia-inhouse/env": "3.3.11",
-        "@diia-inhouse/errors": "2.1.10",
-        "@diia-inhouse/oxc-config": "1.10.2",
-        "@diia-inhouse/test": "8.2.8",
+        "@diia-inhouse/env": "3.3.12",
+        "@diia-inhouse/errors": "2.1.11",
+        "@diia-inhouse/oxc-config": "1.11.0",
+        "@diia-inhouse/test": "8.2.9",
         "@diia-inhouse/types": "13.2.2",
-        "@diia-inhouse/utils": "6.0.20",
-        "@diia-inhouse/validators": "2.2.16",
+        "@diia-inhouse/utils": "6.0.21",
+        "@diia-inhouse/validators": "2.2.17",
         "@opentelemetry/api": "1.9.0",
         "@types/lodash": "4.17.24",
         "@types/node": "25.6.2",

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

@@ -1,20 +0,0 @@
-import { Headers } from "./index.js";
-import { MessagePropertyHeaders } from "amqplib/properties";
-
-//#region src/interfaces/providers/rabbitmq/amqpPublisher.d.ts
-type MessagePayload = unknown;
-interface MessageHeaders {
-  traceId: string;
-  serviceCode?: string;
-  "x-delay"?: number;
-}
-interface DirectResponseHeaders extends MessagePropertyHeaders {
-  [Headers.handledBy]?: string;
-}
-interface DirectResponse<T = unknown> extends MessagePropertyHeaders {
-  body: T;
-  headers: DirectResponseHeaders;
-}
-type PublishingResult = void;
-//#endregion
-export { DirectResponse, DirectResponseHeaders, MessageHeaders, MessagePayload, PublishingResult };