@diia-inhouse/diia-queue 8.0.0 → 13.2.1

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

@@ -1,23 +1,34 @@
 import * as amqp from 'amqplib';
+import { ErrorData } from '@diia-inhouse/errors/dist/types/interfaces';
 import { AmqpConnection } from '../../../providers/rabbitmq/amqpConnection';
+import { BaseQueueOptions } from '../../messageBrokerServiceConfig';
 import { ListenerOptions } from '../../options';
-import { EventName } from '../../queueConfig';
+import { EventName, QueueConfigByQueueName, ServiceConfigByConfigType, TopicConfigByConfigType } from '../../queueConfig';
 import { ConnectOptions, ConnectionStatus, ReconnectOptions, SocketOptions } from './amqpConnection';
-export * from './amqpConnection';
-export * from './amqpPublisher';
 export interface RabbitMQConfigCustomParams {
     responseRoutingKeyPrefix?: string;
 }
+export interface DeclareOptions {
+    assertQueues?: boolean;
+    assertExchanges?: boolean;
+    queuesOptions?: BaseQueueOptions;
+}
 export interface RabbitMQConfig {
     connection: ConnectOptions;
     socketOptions?: SocketOptions;
     reconnectOptions?: ReconnectOptions;
     custom?: RabbitMQConfigCustomParams;
-    assertExchanges?: boolean;
     listenerOptions: ListenerOptions;
+    declareOptions?: DeclareOptions;
+    /**
+     * Whether to create consumer (listener) connections. When `false`, only publisher
+     * and asserter connections are established. Defaults to `true`.
+     */
+    consumerEnabled?: boolean;
 }
 export declare enum ConnectionClientType {
     Listener = "listener",
+    Asserter = "asserter",
     Publisher = "publisher"
 }
 export type ConnectionList = {
@@ -30,21 +41,74 @@ export interface QueueMessageMetaData {
     xid?: string;
     responseRoutingKey?: string;
     ignoreCache?: boolean;
+    registryApiVersion?: string;
+}
+export interface QueueMessageError {
+    data: ErrorData;
+    message: string;
+    http_code: number;
 }
 export interface QueueMessageData<T = any> {
     event: EventName | string;
     payload: T;
     meta: QueueMessageMetaData;
 }
+export type MessageData = Pick<QueueMessageData, 'payload' | 'event'>;
+export declare class Message<T = unknown> {
+    data: QueueMessageData<T>;
+    constructor(data: QueueMessageData<T>);
+}
 export type MessageProperties = amqp.MessageProperties;
 export interface QueueMessage {
     id?: unknown;
     data: QueueMessageData;
     properties: MessageProperties;
-    done: (data?: unknown) => void;
-    reject: () => void;
+    done: (data?: QueueMessageData) => void;
+    reject: (nackOptions: NackOptions) => void;
 }
 export interface RabbitMQStatus {
-    listener: ConnectionStatus;
+    listener?: ConnectionStatus;
     publisher: ConnectionStatus;
 }
+export interface ExportConfig {
+    queues: QueueConfigByQueueName;
+    rabbit: RabbitMQConfig;
+    topics: TopicConfigByConfigType;
+    service: ServiceConfigByConfigType;
+    portalEvents: EventName[];
+}
+export declare const Headers: {
+    readonly sentFrom: "sent-from";
+    readonly handledBy: "handled-by";
+};
+export declare class NackOptions {
+    /**
+     * If requeue is truthy, the server will try to put the message or messages back on the queue or queues from which they came.
+     * Defaults to true if not given, so if you want to make sure messages are dead-lettered or discarded, supply false here.
+     */
+    readonly requeue: boolean;
+    /**
+     * If allUpTo is truthy, all outstanding messages prior to and including the given message are rejected. Defaults to false.
+     */
+    readonly allUpTo: boolean;
+    constructor(
+    /**
+     * If requeue is truthy, the server will try to put the message or messages back on the queue or queues from which they came.
+     * Defaults to true if not given, so if you want to make sure messages are dead-lettered or discarded, supply false here.
+     */
+    requeue?: boolean, 
+    /**
+     * If allUpTo is truthy, all outstanding messages prior to and including the given message are rejected. Defaults to false.
+     */
+    allUpTo?: boolean);
+}
+export declare const Arguments: {
+    readonly queueType: "x-queue-type";
+    /**
+     * @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
+     */
+    readonly delayedType: "x-delayed-type";
+    readonly deliveryLimit: "x-delivery-limit";
+    readonly deadLetterExchange: "x-dead-letter-exchange";
+    readonly deadLetterExchangeRoutingKey: "x-dead-letter-routing-key";
+};

package/dist/types/interfaces/queueConfig/configs.d.ts

@@ -1,39 +1,47 @@
+import { ExchangeName, MessageBrokerServicesConfig } from '../messageBrokerServiceConfig';
 export type EventName = string;
 export type QueueName = string;
-export type Topic = string;
 export declare enum QueueConfigType {
     Internal = "internal",
     External = "external"
 }
 export interface InternalServiceConfig {
     subscribe?: QueueName[];
-    publish?: Topic[];
+    publish?: ExchangeName[];
 }
 export interface ExternalServiceConfig {
-    publish: EventName[];
+    /**
+     * add an event to this field only in cases when you don't need to await a response to an event;
+     * in other cases, use the *receiveDirect* mechanism
+     * */
+    publish?: EventName[];
     subscribe: EventName[];
 }
 export type ServiceConfigByConfigType = InternalServiceConfig | ExternalServiceConfig;
 export interface ServiceConfig {
-    [QueueConfigType.Internal]: InternalServiceConfig;
-    [QueueConfigType.External]: ExternalServiceConfig;
+    /**
+     * @deprecated no need to set the internal service queues config, because it is used nowhere.
+     * it should be deleted from a service config
+     * */
+    [QueueConfigType.Internal]?: InternalServiceConfig;
+    [QueueConfigType.External]?: ExternalServiceConfig;
 }
 export type QueueConfigByQueueName = {
-    [k in QueueName]?: {
-        topics: Topic[];
+    [k in QueueName]: {
+        topics: ExchangeName[];
     };
 };
 export type QueueConfig = Record<QueueConfigType.Internal, QueueConfigByQueueName>;
 export type TopicConfigByConfigType = {
-    [k in Topic]?: {
+    [k in ExchangeName]: {
         events: EventName[];
     };
 };
 export type TopicConfig = Record<QueueConfigType, TopicConfigByConfigType>;
 export type ServiceRulesConfig = {
-    servicesConfig: ServiceConfig;
     topicsConfig: TopicConfig;
     queuesConfig: QueueConfig;
-    portalEvents: EventName[];
-    internalEvents: EventName[];
+    portalEvents?: EventName[];
+    servicesConfig?: ServiceConfig;
+    messageBrokerServices?: MessageBrokerServicesConfig;
 };

package/dist/types/interfaces/queueStatus.d.ts

@@ -1,9 +1,11 @@
+import { MessageBrokerServiceType } from './messageBrokerServiceConfig';
 import { RabbitMQStatus } from './providers/rabbitmq';
 export declare enum QueueConnectionType {
     Internal = "internal",
     External = "external"
 }
-export type QueueStatusByType = Partial<Record<QueueConnectionType, RabbitMQStatus>>;
+export type MessageBrokerServicesStatus = Partial<Record<MessageBrokerServiceType, RabbitMQStatus>>;
+export type QueueStatusByType = Partial<Record<QueueConnectionType, MessageBrokerServicesStatus>>;
 export type QueueStatus = {
     rabbit: QueueStatusByType;
 };

package/dist/types/interfaces/services/eventMessageHandler.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from '@diia-inhouse/errors';
+export interface ValidationResult {
+    isValid: boolean;
+    error?: ValidationError;
+}

package/dist/types/metrics/index.d.ts

@@ -1,4 +1,3 @@
 import { Counter } from '@diia-inhouse/diia-metrics';
-import { TotalListenerChannelErrorsLabelsMap, TotalMessageHandlerErrorsLabelsMap } from '../interfaces/metrics';
+import { TotalListenerChannelErrorsLabelsMap } from '../interfaces/metrics';
 export declare const totalListenerChannelErrorsMetric: Counter<TotalListenerChannelErrorsLabelsMap>;
-export declare const totalMessageHandlerErrorsMetrics: Counter<TotalMessageHandlerErrorsLabelsMap>;

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

@@ -0,0 +1,5 @@
+export * from './rabbitmq';
+export * from './rabbitmq/amqpListener';
+export * from './rabbitmq/amqpAsserter';
+export * from './rabbitmq/amqpPublisher';
+export * from './rabbitmq/amqpConnection';

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

@@ -0,0 +1,49 @@
+import { Replies } from 'amqplib';
+import { Logger } from '@diia-inhouse/types';
+import { DeclareOptions } from '../../interfaces';
+import { BindOptions, ExchangeName, ExchangeOptions, QueueOptions, UnbindOptions } from '../../interfaces/messageBrokerServiceConfig';
+import { QueueName } from '../../interfaces/queueConfig';
+import { AmqpConnection } from './amqpConnection';
+export declare class AmqpAsserter {
+    private readonly connection;
+    private readonly logger;
+    private readonly declareOptions;
+    static PrefixAlternate: string;
+    private readonly defaultExchangeType;
+    private readonly defaultQueueOptions;
+    private readonly defaultExchangeOptions;
+    private readonly defaultDeclareOptions;
+    private channel?;
+    private readonly channelName;
+    constructor(connection: AmqpConnection, logger: Logger, declareOptions?: DeclareOptions);
+    init(exchangesOptions?: ExchangeOptions[], queuesOptions?: QueueOptions[]): Promise<void>;
+    declareQueuesByJSON(declarationConfigPath: string): Promise<void>;
+    declareQueues(queuesOptions?: QueueOptions[], exchangesOptions?: ExchangeOptions[]): Promise<void>;
+    redeclareQueue(queueOptions: QueueOptions, exchangesOptions: ExchangeOptions[]): Promise<boolean>;
+    transferMessageBetweenQueues(sourceQueueName: QueueName, destinationQueueName: QueueName): Promise<void>;
+    deleteExchanges(exchangesOptions: ExchangeOptions[]): Promise<Record<ExchangeName, Replies.Empty | undefined>>;
+    deleteExchange(exchangeName: string): Promise<Replies.Empty | undefined>;
+    deleteQueues(queueNames: QueueName[]): Promise<Record<QueueName, Replies.DeleteQueue | undefined>>;
+    deleteQueue(queueName: QueueName): Promise<Replies.DeleteQueue | undefined>;
+    assertQueues(queueOptions: QueueOptions[]): Promise<Record<QueueName, Replies.AssertQueue | undefined>>;
+    assertQueue(queueOptions: QueueOptions): Promise<Replies.AssertQueue | undefined>;
+    assertExchanges(exchangeOptions: ExchangeOptions[]): Promise<Record<QueueName, Replies.AssertExchange | undefined>>;
+    assertExchange(exchangeOptions: ExchangeOptions): Promise<Replies.AssertExchange | undefined>;
+    unbindQueueFromExchanges(queueOptions: QueueOptions): Promise<undefined>;
+    bindQueueToExchange(queueName: QueueName, bindOptions: BindOptions): Promise<Replies.Empty | undefined>;
+    bindExchangeToExchanges(exchangeName: ExchangeName, bindTo: BindOptions[]): Promise<undefined>;
+    bindExchangeToExchange(exchangeName: ExchangeName, bindOptions: BindOptions): Promise<Replies.Empty | undefined>;
+    unbindQueueFromExchange(queueName: QueueName, unbindOptions: UnbindOptions): Promise<Replies.Empty | undefined>;
+    disconnect(): Promise<void>;
+    private initChannel;
+    private readConfig;
+    private assertTemporaryQueue;
+    private assertAlternateExchanges;
+    private assertAlternateQueue;
+    private prepareRedeclareQueueOptions;
+    private prepareTemporaryQueueOptions;
+    private prepareAlternateExchangesOptions;
+    private prepareAlternateExchangeOptions;
+    private prepareAlternateQueueOptions;
+    private prepareAlternateBindToQueueOption;
+}

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { EventEmitter } from 'node:events';
 import { Channel, Options } from 'amqplib';
 import { Logger } from '@diia-inhouse/types';
@@ -10,14 +9,11 @@ export declare class AmqpConnection extends EventEmitter {
     private readonly socketOptions;
     private reconnectEnabled;
     private reconnectTimeout;
-    private connection;
+    private connection?;
     private connectionStatus;
-    constructor(connectOptions: Options.Connect, logger: Logger, reconnectOptions?: ReconnectOptions, socketOptions?: SocketOptions);
+    constructor(connectOptions: Options.Connect, logger: Logger, reconnectOptions?: ReconnectOptions | undefined, socketOptions?: SocketOptions);
     connect(): Promise<void>;
-    /**
-     * Create new channel
-     */
-    createChannel(queueName: string): Promise<Channel>;
+    createChannel(queueName?: string): Promise<Channel>;
     reconnect(): Promise<void>;
     closeConnection(): Promise<void>;
     getStatus(): ConnectionStatus;

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

@@ -1,27 +1,42 @@
-import { Options, Replies } from 'amqplib';
 import { Logger } from '@diia-inhouse/types';
-import { ListenerOptions } from '../../interfaces/options';
+import { MessageHandler, QueueOptions } from '../../interfaces';
 import { ConnectionStatus } from '../../interfaces/providers/rabbitmq/amqpConnection';
-import { QueueCallback } from '../../interfaces/providers/rabbitmq/amqpListener';
+import { QueueName } from '../../interfaces/queueConfig';
+import RabbitMQMetricsService from '../../services/metrics';
 import { AmqpConnection } from './amqpConnection';
 export declare class AmqpListener {
     private connection;
     private readonly logger;
-    private readonly options?;
-    private queuesChannels;
-    private queueCallback;
-    constructor(connection: AmqpConnection, logger: Logger, options?: ListenerOptions);
+    private readonly rabbitMQMetrics;
+    private readonly queuesOptions;
+    private readonly systemServiceName;
+    private readonly infiniteRecreateChannelTriesCount;
+    private readonly defaultRecreateChannelOptions;
+    private readonly defaultPrefetchCount;
+    private queuesChannelsMap;
+    private queueRecreateChannelTriesMap;
+    private readonly defaultNackOptions;
+    private queuesCallbacksMap;
+    private queueConsumerOptionsMap;
+    private queueConsumerTagsMap;
+    private readonly nullMessage;
+    constructor(connection: AmqpConnection, logger: Logger, rabbitMQMetrics: RabbitMQMetricsService, queuesOptions: QueueOptions[] | undefined, systemServiceName: string);
     init(): Promise<void>;
-    listenQueue(queueName: string, callback: QueueCallback, queueOptions?: Options.AssertQueue): Promise<void | never>;
-    bindQueueToExchange(queueName: string, exchangeName: string, routingKey?: string): Promise<Replies.Empty>;
+    cancelQueue(queueName: QueueName): Promise<void>;
+    listenQueue(queueName: QueueName, callback: MessageHandler): Promise<void | never>;
     getStatus(): ConnectionStatus;
     private ackMsg;
     private nackMsg;
     private createChannelAndListenQueue;
     private saveQueueCallback;
     private getQueueCallback;
-    private getChannel;
-    private getQueueOptions;
     private saveChannel;
     private onMessageCallback;
+    private handleChannelError;
+    private parseMessage;
+    private prepareResponse;
+    private finishResponseProcessing;
+    private getConsumerOptions;
+    private getQueueChannel;
+    private saveConsumerTag;
 }

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

@@ -1,25 +1,34 @@
-import { Options, Replies } from 'amqplib';
 import { Logger } from '@diia-inhouse/types';
+import { ExchangeName } from '../../interfaces/messageBrokerServiceConfig';
+import { PublisherOptions } from '../../interfaces/options';
+import { QueueMessageData } from '../../interfaces/providers/rabbitmq';
 import { ConnectionStatus } from '../../interfaces/providers/rabbitmq/amqpConnection';
-import { ExchangeType, PublishToExchangeParams } from '../../interfaces/providers/rabbitmq/amqpPublisher';
+import { MessageHeaders, PublishingResult } from '../../interfaces/providers/rabbitmq/amqpPublisher';
+import RabbitMQMetricsService from '../../services/metrics';
 import { AmqpConnection } from './amqpConnection';
 export declare class AmqpPublisher {
     private readonly connection;
     private readonly logger;
-    private readonly timeout;
-    readonly defaultExchangeType = ExchangeType.Topic;
-    private channel;
-    private eventEmitter;
-    private readonly defaultExchangeOptions;
-    constructor(connection: AmqpConnection, logger: Logger, timeout?: number);
+    private readonly rabbitMQMetrics;
+    private readonly systemServiceName;
+    private readonly defaultPublishOptions;
+    private rpcChannel?;
+    private regularChannel?;
+    private readonly replyToQueueName;
+    private eventEmitter?;
+    private readonly directResponseTimeout;
+    constructor(connection: AmqpConnection, logger: Logger, rabbitMQMetrics: RabbitMQMetricsService, systemServiceName: string, options?: PublisherOptions);
     init(): Promise<void>;
-    private createChannel;
-    publishToExchange(params: PublishToExchangeParams): Promise<boolean>;
-    publishToExchangeDirect<T>(params: PublishToExchangeParams): Promise<T>;
-    private static prepareQueueMessageData;
-    private publishDirect;
-    private publish;
-    private static defaultPublishOptions;
-    checkExchange(exchangeName: string, exchangeType?: ExchangeType, options?: Options.AssertExchange): Promise<Replies.AssertExchange>;
+    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>;
     getStatus(): ConnectionStatus;
+    private createRegularChannel;
+    private createRpcChannel;
+    private listenReplyToQueue;
+    private publishMessage;
+    private publishRequest;
+    private publish;
+    private getPublishOptions;
+    private receiveDirectResponse;
+    private collectMetrics;
 }

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

@@ -1,59 +1,52 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { type AsyncLocalStorage } from 'node:async_hooks';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { EventEmitter } from 'node:events';
+import { MetricsService } from '@diia-inhouse/diia-metrics';
 import { Logger } from '@diia-inhouse/types';
+import { PublishingResult } from '../../interfaces';
+import { MessageBrokerServiceConfig, QueueOptions } from '../../interfaces/messageBrokerServiceConfig';
 import { MessageHandler } from '../../interfaces/messageHandler';
-import { ListenerOptions, PublishDirectOptions, PublishExternalEventOptions, PublishInternalEventOptions, SubscribeOptions } from '../../interfaces/options';
-import { RabbitMQConfig, RabbitMQStatus } from '../../interfaces/providers/rabbitmq';
-import { MessagePayload } from '../../interfaces/providers/rabbitmq/amqpPublisher';
-import { EventName, QueueConfigByQueueName, QueueConfigType, QueueName, ServiceConfigByConfigType, Topic, TopicConfigByConfigType } from '../../interfaces/queueConfig';
+import { PublishDirectOptions, PublishOptions } from '../../interfaces/options';
+import { ConnectionClientType, ExportConfig, QueueMessageData, RabbitMQConfig, RabbitMQStatus } from '../../interfaces/providers/rabbitmq';
+import { EventName, QueueConfigByQueueName, QueueName, ServiceConfigByConfigType, TopicConfigByConfigType } from '../../interfaces/queueConfig';
 import { QueueContext } from '../../interfaces/queueContext';
+import { AmqpAsserter } from './amqpAsserter';
+import { AmqpConnection } from './amqpConnection';
+import { AmqpListener } from './amqpListener';
+import { AmqpPublisher } from './amqpPublisher';
 export declare class RabbitMQProvider extends EventEmitter {
-    private readonly serviceName;
+    private readonly systemServiceName;
     private readonly rabbitmqConfig;
     private readonly serviceConfig;
     private readonly topicsConfig;
     private readonly portalEvents;
-    private readonly internalEvents;
-    private readonly type;
     private readonly logger;
+    private readonly metrics;
     private readonly asyncLocalStorage?;
     private readonly queuesConfig?;
+    private readonly messageBrokerServiceConfig?;
     private initializingLock?;
-    private listener;
-    private publisher;
+    private listener?;
+    private publisher?;
+    private asserter?;
     private connectionList;
-    private readonly projectName;
-    private readonly portalName;
-    private eventNameToTopicMap;
-    private externalPublishEventsSet;
-    private externalSubscribeEventsSet;
-    private assertExternalExchanges?;
-    constructor(serviceName: string, rabbitmqConfig: RabbitMQConfig, serviceConfig: ServiceConfigByConfigType, topicsConfig: TopicConfigByConfigType, portalEvents: EventName[], internalEvents: EventName[], type: QueueConfigType, logger: Logger, asyncLocalStorage?: AsyncLocalStorage<QueueContext>, queuesConfig?: QueueConfigByQueueName);
-    getServiceName(): string;
-    getConfig(): RabbitMQConfig;
-    init(listenerOptions?: ListenerOptions): Promise<void>;
-    subscribe(subscriptionName: QueueName, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
-    publish(eventName: EventName, message: MessagePayload, options?: PublishInternalEventOptions): Promise<boolean>;
-    subscribeTask(queueName: string, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
-    publishTask(queueName: string, message: MessagePayload, delay?: number): Promise<boolean>;
-    subscribeExternal(messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
-    publishExternalDirect<T>(eventName: EventName, message: MessagePayload, topic?: Topic, options?: PublishDirectOptions): Promise<T>;
-    publishExternal(eventName: EventName, message: MessagePayload, options?: PublishExternalEventOptions): Promise<boolean>;
+    private readonly publisherIsNotInitializedErrorMsg;
+    private readonly rabbitMQMetricsService;
+    constructor(systemServiceName: string, rabbitmqConfig: RabbitMQConfig, serviceConfig: ServiceConfigByConfigType, topicsConfig: TopicConfigByConfigType, portalEvents: EventName[], logger: Logger, metrics: MetricsService, asyncLocalStorage?: AsyncLocalStorage<QueueContext> | undefined, queuesConfig?: QueueConfigByQueueName | undefined, messageBrokerServiceConfig?: MessageBrokerServiceConfig | undefined);
+    getConfig(): ExportConfig;
+    getMessageBrokerServiceConfig(): MessageBrokerServiceConfig;
+    init(config?: MessageBrokerServiceConfig): Promise<void>;
+    subscribe(queueName: QueueName, messageHandler: MessageHandler): Promise<boolean>;
+    unsubscribe(queueName: QueueName): Promise<void>;
+    publish(message: QueueMessageData, exchangeName: string, routingKey?: string, options?: PublishOptions): Promise<PublishingResult>;
+    publishExternalDirect<T>(message: QueueMessageData, exchangeName: string, routingKey?: string, options?: PublishDirectOptions): Promise<T>;
     getStatus(): RabbitMQStatus;
-    private preparePublisherHeaders;
-    private findTopicNameByEventName;
+    makeAMQPConnection(client: ConnectionClientType): Promise<AmqpConnection>;
+    makeAMQPListener(queuesOptions: QueueOptions[]): Promise<AmqpListener>;
+    makeAMQPAsserter(): Promise<AmqpAsserter>;
+    makeAMQPPublisher(): Promise<AmqpPublisher>;
     private setListener;
+    private setAsserter;
     private setPublisher;
     private getConnection;
-    private checkAndBindToExchange;
-    private bindQueueToExternalExchange;
-    private makeQueueName;
-    private makeExternalResQueueName;
-    private makeExternalReqQueueName;
-    private prepareExternalTopicName;
-    private prepareExternalReqRoutingKey;
-    private prepareExternalResRoutingKey;
-    private prepareExternalQueuePrefix;
+    private preparePublisherHeaders;
 }

package/dist/types/services/communicator.d.ts

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

package/dist/types/services/eventBus.d.ts

@@ -1,19 +1,20 @@
-import { Logger, OnInit } from '@diia-inhouse/types';
-import { EventBusListener, EventBusQueue } from '../interfaces/eventBus';
-import { MessageHandler } from '../interfaces/messageHandler';
-import { PublishInternalEventOptions, SubscribeOptions } from '../interfaces/options';
+import Logger from '@diia-inhouse/diia-logger';
+import { OnInit } from '@diia-inhouse/types';
+import { EventBusListener, EventBusQueue, ExchangeName, MessageBrokerServiceEventsListener, PublishOptions, PublishingResult } from '../interfaces';
+import { ExchangeOptions } from '../interfaces/messageBrokerServiceConfig';
 import { MessagePayload } from '../interfaces/providers/rabbitmq/amqpPublisher';
-import { QueueName } from '../interfaces/queueConfig';
+import { EventName, QueueName } from '../interfaces/queueConfig';
 import { RabbitMQProvider } from '../providers/rabbitmq';
+import Communicator from './communicator';
 import { EventMessageHandler } from './eventMessageHandler';
-export declare class EventBus implements EventBusQueue, OnInit {
-    private readonly queueProvider;
+export declare class EventBus extends Communicator implements EventBusQueue, OnInit {
     private readonly eventListenerList;
-    private readonly eventMessageHandler;
-    private readonly logger;
-    private readonly queueName;
-    constructor(queueProvider: RabbitMQProvider, eventListenerList: EventBusListener[], eventMessageHandler: EventMessageHandler, logger: Logger, queueName: QueueName | undefined);
-    onInit(): Promise<void>;
-    subscribe(subscriptionName: QueueName, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
-    publish(eventName: QueueName, message: MessagePayload, options?: PublishInternalEventOptions): Promise<boolean>;
+    private readonly queueName?;
+    private readonly eventCommunicator;
+    constructor(queueProvider: RabbitMQProvider, eventListenerList: EventBusListener[], eventMessageHandler: EventMessageHandler, logger: Logger, 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[];
 }

package/dist/types/services/eventCommunicator.d.ts

@@ -0,0 +1,15 @@
+import Logger from '@diia-inhouse/diia-logger';
+import { EventBusListener, EventName, ExchangeOptions, MessageBrokerServiceEventsListener, QueueName, QueueOptions } from '../interfaces';
+import { RabbitMQProvider } from '../providers';
+import { EventMessageHandler } from './eventMessageHandler';
+export declare class EventCommunicator {
+    private readonly logger;
+    private readonly queueProvider;
+    private readonly eventMessageHandler;
+    protected readonly listenerList: EventBusListener[];
+    constructor(logger: Logger, queueProvider: RabbitMQProvider, eventMessageHandler: EventMessageHandler, listenerList?: EventBusListener[]);
+    getMulticastListeners(queuesOptions: QueueOptions[], exchangesOptions: ExchangeOptions[], eventQueueMap?: Map<EventName, QueueName>): MessageBrokerServiceEventsListener[];
+    getUnicastListeners(): MessageBrokerServiceEventsListener[];
+    private defineConsumerExchangesOptions;
+    private defineEventNamesByQueueName;
+}

package/dist/types/services/eventMessageHandler.d.ts

@@ -1,21 +1,19 @@
-/// <reference types="node" />
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { PubSubService } from '@diia-inhouse/redis';
-import { Logger } from '@diia-inhouse/types';
-import { EventBusListener, QueueContext, QueueMessage, TaskListener } from '../interfaces';
-import { EventListeners } from '../interfaces/externalCommunicator';
+import Logger from '@diia-inhouse/diia-logger';
+import { EventBusListener, EventListeners, QueueContext, QueueMessage, TaskListener } from '../interfaces';
 import { EventMessageValidator } from './eventMessageValidator';
-import { ExternalCommunicatorChannel } from './externalCommunicatorChannel';
 export declare class EventMessageHandler {
     private readonly eventMessageValidator;
-    private readonly externalChannel;
-    private readonly pubsub;
     private readonly asyncLocalStorage;
     private readonly logger;
-    constructor(eventMessageValidator: EventMessageValidator, externalChannel: ExternalCommunicatorChannel, pubsub: PubSubService, asyncLocalStorage: AsyncLocalStorage<QueueContext>, logger: Logger);
+    private readonly noRequeueNackOptions;
+    constructor(eventMessageValidator: EventMessageValidator, asyncLocalStorage: AsyncLocalStorage<QueueContext>, logger: Logger);
     eventListenersMessageHandler(this: this, eventListeners: EventListeners, message: QueueMessage | null): Promise<void>;
     eventListenerMessageHandler(listener: EventBusListener | TaskListener | undefined, message: QueueMessage): Promise<void>;
-    private syncMessageHandler;
-    private performDone;
+    private prepareAsyncContext;
+    private handleMessage;
+    private validateData;
+    private directReplyDone;
     private getServiceCode;
+    private prepareQueueMessageError;
 }