@diia-inhouse/diia-queue 13.3.3 → 14.0.10

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

@@ -1,79 +0,0 @@
-import { Options } from 'amqplib';
-interface BaseBindOptions {
-    exchangeName: string;
-    routingKey?: string;
-}
-export interface BindOptions extends BaseBindOptions {
-    bind?: boolean;
-}
-export interface UnbindOptions extends BaseBindOptions {
-    unbind?: boolean;
-}
-export interface RecreateChannelOptions {
-    timeout?: number;
-    maxTries?: number;
-    backoffCoefficient?: number;
-}
-export interface ConsumerOptions {
-    consumerTag?: string;
-    prefetchCount?: number;
-    recreateChannelOptions?: RecreateChannelOptions;
-}
-export type ExchangeName = string;
-export declare enum ExchangeType {
-    Direct = "direct",
-    Fanout = "fanout",
-    Topic = "topic",
-    Headers = "headers",
-    /**
-     * @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
-     */
-    XDelayedMessage = "x-delayed-message"
-}
-export interface ExchangeOptions {
-    name: ExchangeName;
-    type?: ExchangeType;
-    declare?: boolean;
-    /**
-     * @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
-     */
-    delayed?: boolean;
-    options?: Options.AssertExchange;
-    bindTo?: BindOptions[];
-}
-export declare const MessageBrokerExternalServiceTypes: readonly ["externalEventBus"];
-export type MessageBrokerExternalServiceType = (typeof MessageBrokerExternalServiceTypes)[number];
-export declare const MessageBrokerInternalServiceTypes: readonly ["task", "eventBus", "scheduledTask"];
-export type MessageBrokerInternalServiceType = (typeof MessageBrokerInternalServiceTypes)[number];
-export declare const MessageBrokerGeneralServiceTypes: readonly ["general"];
-export type MessageBrokerGeneralServiceType = (typeof MessageBrokerGeneralServiceTypes)[number];
-export type MessageBrokerServiceType = MessageBrokerExternalServiceType | MessageBrokerInternalServiceType | MessageBrokerGeneralServiceType;
-export interface MessageBrokerServiceConfig {
-    queuesOptions: QueueOptions[];
-    exchangesOptions: ExchangeOptions[];
-}
-export declare const emptyMessageBrokerServiceConfig: MessageBrokerServiceConfig;
-export type MessageBrokerServicesConfig = {
-    [k in MessageBrokerServiceType]?: MessageBrokerServiceConfig;
-};
-export declare const QueueTypes: {
-    readonly Quorum: "quorum";
-    readonly Classic: "classic";
-};
-type QueueType = (typeof QueueTypes)[keyof typeof QueueTypes];
-export interface BaseQueueOptions {
-    type?: QueueType;
-    options?: Options.AssertQueue;
-}
-export interface RedeclareQueueOptions extends BaseQueueOptions {
-    redeclare?: boolean;
-}
-export interface QueueOptions extends BaseQueueOptions {
-    name: string;
-    declare?: boolean;
-    bindTo: BindOptions[];
-    unbindFrom?: UnbindOptions[];
-    consumerOptions?: ConsumerOptions;
-    redeclareOptions?: RedeclareQueueOptions;
-}
-export {};

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

@@ -1,2 +0,0 @@
-import { QueueMessage } from './providers/rabbitmq';
-export type MessageHandler = (msg: QueueMessage) => Promise<void>;

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

@@ -1,20 +0,0 @@
-export interface TotalListenerChannelErrorsLabelsMap {
-    queueName: string;
-}
-export interface TotalMessageHandlerErrorsLabelsMap {
-    event: string;
-    serviceName: string;
-}
-export declare const LabelUnknown = "unknown";
-export type CommunicationDirection = ['inbound', 'outbound'][number];
-export declare class CommunicationsTotalLabelsMap {
-    event: string;
-    source: string;
-    queue?: string;
-    destination?: string;
-    direction: CommunicationDirection;
-}
-export declare const communicationsTotalLabelsMap: (keyof CommunicationsTotalLabelsMap)[];
-export declare const Metrics: {
-    readonly CommunicationsTotal: "diia_rabbitmq_communications_total";
-};

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

@@ -1,49 +0,0 @@
-import { Options } from 'amqplib';
-import { RecreateChannelOptions } from './messageBrokerServiceConfig';
-export interface PublisherOptions {
-    timeout?: number;
-    replyToQueueName?: string;
-}
-export interface ListenerOptions {
-    queueOptions?: Options.AssertQueue;
-    prefetchCount?: number;
-    recreateChannelOptions?: RecreateChannelOptions;
-}
-export interface PublishDirectOptions {
-    exchangeName?: string;
-    timeout?: number;
-    ignoreCache?: boolean;
-    registryApiVersion?: string;
-}
-export interface PublishOptions {
-    /**
-     * Delay (ms) before message delivery
-     * @default undefined
-     */
-    delay?: number;
-    /**
-     * Routing key for message routing
-     * @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;
-}
-export interface SubscribeOptions {
-    routingKey?: string;
-    listener?: ListenerOptions;
-    /**
-     * @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
-     */
-    delayed?: boolean;
-}
-export interface PublishExternalEventOptions extends PublishOptions, PublishDirectOptions {
-}

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

@@ -1,29 +0,0 @@
-import { Options } from 'amqplib';
-export interface AmqpConfig {
-    protocol?: string;
-    hostname?: string;
-    port?: number;
-    username?: string;
-    password?: string;
-    heartbeat?: number;
-}
-export type ConnectOptions = Options.Connect;
-export interface SocketOptions {
-    clientProperties?: Record<string, any>;
-}
-export interface ReconnectOptions {
-    reconnectEnabled?: boolean;
-    reconnectTimeout?: number;
-}
-export declare enum ConnectionStatus {
-    Init = "init",
-    Connecting = "connecting",
-    Connected = "connected",
-    Reconnecting = "reconnecting",
-    Closing = "closing",
-    Closed = "closed",
-    Down = "down"
-}
-export declare const AmqpConnectionEventNames: {
-    readonly Ready: "ready";
-};

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

@@ -1,16 +0,0 @@
-import { MessagePropertyHeaders } from 'amqplib/properties';
-import { Headers } from './index';
-export type MessagePayload = unknown;
-export interface MessageHeaders {
-    traceId: string;
-    serviceCode?: string;
-    'x-delay'?: number;
-}
-export interface DirectResponseHeaders extends MessagePropertyHeaders {
-    [Headers.handledBy]?: string;
-}
-export interface DirectResponse<T = unknown> extends MessagePropertyHeaders {
-    body: T;
-    headers: DirectResponseHeaders;
-}
-export type PublishingResult = void | never;

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

@@ -1,114 +0,0 @@
-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, QueueConfigByQueueName, ServiceConfigByConfigType, TopicConfigByConfigType } from '../../queueConfig';
-import { ConnectOptions, ConnectionStatus, ReconnectOptions, SocketOptions } from './amqpConnection';
-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;
-    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 = {
-    [k in ConnectionClientType]: {
-        lock?: Promise<AmqpConnection>;
-    };
-};
-export interface QueueMessageMetaData {
-    date: Date;
-    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?: QueueMessageData) => void;
-    reject: (nackOptions: NackOptions) => void;
-}
-export interface RabbitMQStatus {
-    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,47 +0,0 @@
-import { ExchangeName, MessageBrokerServicesConfig } from '../messageBrokerServiceConfig';
-export type EventName = string;
-export type QueueName = string;
-export declare enum QueueConfigType {
-    Internal = "internal",
-    External = "external"
-}
-export interface InternalServiceConfig {
-    subscribe?: QueueName[];
-    publish?: ExchangeName[];
-}
-export interface ExternalServiceConfig {
-    /**
-     * 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 {
-    /**
-     * @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: ExchangeName[];
-    };
-};
-export type QueueConfig = Record<QueueConfigType.Internal, QueueConfigByQueueName>;
-export type TopicConfigByConfigType = {
-    [k in ExchangeName]: {
-        events: EventName[];
-    };
-};
-export type TopicConfig = Record<QueueConfigType, TopicConfigByConfigType>;
-export type ServiceRulesConfig = {
-    topicsConfig: TopicConfig;
-    queuesConfig: QueueConfig;
-    portalEvents?: EventName[];
-    servicesConfig?: ServiceConfig;
-    messageBrokerServices?: MessageBrokerServicesConfig;
-};

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

@@ -1 +0,0 @@
-export * from './configs';

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

@@ -1,4 +0,0 @@
-import { LogData } from '@diia-inhouse/types';
-export interface QueueContext {
-    logData?: LogData;
-}

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

@@ -1,11 +0,0 @@
-import { MessageBrokerServiceType } from './messageBrokerServiceConfig';
-import { RabbitMQStatus } from './providers/rabbitmq';
-export declare enum QueueConnectionType {
-    Internal = "internal",
-    External = "external"
-}
-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

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

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

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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,20 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { Channel, Options } from 'amqplib';
-import { Logger } from '@diia-inhouse/types';
-import { ConnectionStatus, ReconnectOptions, SocketOptions } from '../../interfaces/providers/rabbitmq/amqpConnection';
-export declare class AmqpConnection extends EventEmitter {
-    private readonly connectOptions;
-    private readonly logger;
-    private readonly reconnectOptions?;
-    private readonly socketOptions;
-    private reconnectEnabled;
-    private reconnectTimeout;
-    private connection?;
-    private connectionStatus;
-    constructor(connectOptions: Options.Connect, logger: Logger, reconnectOptions?: ReconnectOptions | undefined, socketOptions?: SocketOptions);
-    connect(): Promise<void>;
-    createChannel(queueName?: string): Promise<Channel>;
-    reconnect(): Promise<void>;
-    closeConnection(): Promise<void>;
-    getStatus(): ConnectionStatus;
-}

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

@@ -1,42 +0,0 @@
-import { Logger } from '@diia-inhouse/types';
-import { MessageHandler, QueueOptions } from '../../interfaces';
-import { ConnectionStatus } from '../../interfaces/providers/rabbitmq/amqpConnection';
-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 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>;
-    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 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,34 +0,0 @@
-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 { 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 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>;
-    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,52 +0,0 @@
-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 { 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 systemServiceName;
-    private readonly rabbitmqConfig;
-    private readonly serviceConfig;
-    private readonly topicsConfig;
-    private readonly portalEvents;
-    private readonly logger;
-    private readonly metrics;
-    private readonly asyncLocalStorage?;
-    private readonly queuesConfig?;
-    private readonly messageBrokerServiceConfig?;
-    private initializingLock?;
-    private listener?;
-    private publisher?;
-    private asserter?;
-    private connectionList;
-    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;
-    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 preparePublisherHeaders;
-}

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

@@ -1,57 +0,0 @@
-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;
-}