@diia-inhouse/diia-queue 13.3.3 → 14.0.10

package/dist/constants.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
-    DEFAULT_ROUTING_KEY: '*',
-    APP_ID: 'Diia App',
-    PROJECT_NAME: 'diia',
-    PORTAL_NAME: 'portal',
-    REPLY_TO_QUEUE_NAME: 'amq.rabbitmq.reply-to',
+//#region src/constants.ts
+var constants_default = {
+	DEFAULT_ROUTING_KEY: "*",
+	APP_ID: "Diia App",
+	PROJECT_NAME: "diia",
+	PORTAL_NAME: "portal",
+	REPLY_TO_QUEUE_NAME: "amq.rabbitmq.reply-to"
 };
-//# sourceMappingURL=constants.js.map
+//#endregion
+export { constants_default as default };

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+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 { 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 { 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";
+import { ExternalCommunicatorFailureResponse, ExternalCommunicatorResponse, ExternalCommunicatorResponseError, ExternalCommunicatorSuccessResponse, ReceiveDirectOps } from "./interfaces/externalCommunicator.js";
+import { EventBusListener, EventBusQueue, EventListeners, ExternalEventBusQueue, InternalQueueConfig, Listener, MessageBrokerServiceEventsListener, MessageBrokerServiceListener, QueueConfig, QueueConnectionConfig, ScheduledTasksQueue, TaskListener, TaskQueue } from "./interfaces/index.js";
+import { AmqpAsserter } from "./providers/rabbitmq/amqpAsserter.js";
+import { AmqpListener } from "./providers/rabbitmq/amqpListener.js";
+import { AmqpPublisher } from "./providers/rabbitmq/amqpPublisher.js";
+import { RabbitMQProvider } from "./providers/rabbitmq/index.js";
+import { EventMessageValidator } from "./services/eventMessageValidator.js";
+import { EventMessageHandler } from "./services/eventMessageHandler.js";
+import { EventBus } from "./services/eventBus.js";
+import { ExternalCommunicator } from "./services/externalCommunicator.js";
+import { ExternalEventBus } from "./services/externalEventBus.js";
+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 };

package/dist/index.js

@@ -1,21 +1,23 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./interfaces"), exports);
-__exportStar(require("./interfaces/deps"), exports);
-__exportStar(require("./services"), exports);
-__exportStar(require("./providers"), exports);
-//# sourceMappingURL=index.js.map
+import { Arguments, ConnectionClientType, Headers, Message, NackOptions } from "./interfaces/providers/rabbitmq/index.js";
+import { AmqpConnectionEventNames, ConnectionStatus } from "./interfaces/providers/rabbitmq/amqpConnection.js";
+import { QueueConnectionType } from "./interfaces/queueStatus.js";
+import { ExchangeType, MessageBrokerExternalServiceTypes, MessageBrokerGeneralServiceTypes, MessageBrokerInternalServiceTypes, QueueTypes, emptyMessageBrokerServiceConfig } from "./interfaces/messageBrokerServiceConfig.js";
+import { CommunicationsTotalLabelsMap, LabelUnknown, Metrics, communicationsTotalLabelsMap } from "./interfaces/metrics/index.js";
+import { QueueConfigType } from "./interfaces/queueConfig/configs.js";
+import "./interfaces/index.js";
+import { EventBus } from "./services/eventBus.js";
+import { EventMessageHandler } from "./services/eventMessageHandler.js";
+import { EventMessageValidator } from "./services/eventMessageValidator.js";
+import { ExternalCommunicator } from "./services/externalCommunicator.js";
+import { ExternalEventBus } from "./services/externalEventBus.js";
+import { ScheduledTask } from "./services/scheduledTask.js";
+import { Task } from "./services/task.js";
+import { AmqpAsserter } from "./providers/rabbitmq/amqpAsserter.js";
+import { AmqpConnection } from "./providers/rabbitmq/amqpConnection.js";
+import { AmqpListener } from "./providers/rabbitmq/amqpListener.js";
+import { AmqpPublisher } from "./providers/rabbitmq/amqpPublisher.js";
+import { RabbitMQProvider } from "./providers/rabbitmq/index.js";
+import { Queue } from "./services/queue.js";
+import "./services/index.js";
+import "./providers/index.js";
+export { AmqpAsserter, AmqpConnection, AmqpConnectionEventNames, AmqpListener, AmqpPublisher, Arguments, CommunicationsTotalLabelsMap, ConnectionClientType, ConnectionStatus, EventBus, EventMessageHandler, EventMessageValidator, ExchangeType, ExternalCommunicator, ExternalEventBus, Headers, LabelUnknown, Message, MessageBrokerExternalServiceTypes, MessageBrokerGeneralServiceTypes, MessageBrokerInternalServiceTypes, Metrics, NackOptions, Queue, QueueConfigType, QueueConnectionType, QueueTypes, RabbitMQProvider, ScheduledTask, Task, communicationsTotalLabelsMap, emptyMessageBrokerServiceConfig };

package/dist/interfaces/deps.d.ts

@@ -0,0 +1,30 @@
+import { EventMessageValidator } from "../services/eventMessageValidator.js";
+import { EventMessageHandler } from "../services/eventMessageHandler.js";
+import { EventBus } from "../services/eventBus.js";
+import { ExternalCommunicator } from "../services/externalCommunicator.js";
+import { ExternalEventBus } from "../services/externalEventBus.js";
+import { Queue } from "../services/queue.js";
+import { ScheduledTask } from "../services/scheduledTask.js";
+import { Task } from "../services/task.js";
+
+//#region src/interfaces/deps.d.ts
+type CommonQueueDeps = {
+  queue: Queue;
+  eventMessageHandler: EventMessageHandler;
+  eventMessageValidator: EventMessageValidator;
+};
+type InternalQueueDeps = {
+  eventBus?: EventBus;
+  task?: Task;
+  /**
+  * @deprecated use pkg-workflow entities instead
+  */
+  scheduledTask?: ScheduledTask;
+};
+type ExternalQueueDeps = {
+  externalEventBus: ExternalEventBus;
+  external: ExternalCommunicator;
+};
+type QueueDeps = CommonQueueDeps & InternalQueueDeps & ExternalQueueDeps;
+//#endregion
+export { CommonQueueDeps, ExternalQueueDeps, InternalQueueDeps, QueueDeps };

package/dist/interfaces/externalCommunicator.d.ts

@@ -0,0 +1,58 @@
+import { ExchangeName } from "./messageBrokerServiceConfig.js";
+import { HttpStatusCode } from "@diia-inhouse/types";
+import { ValidationSchema } from "@diia-inhouse/validators";
+
+//#region src/interfaces/externalCommunicator.d.ts
+/**
+* Options for {@link ExternalCommunicator.receiveDirect}.
+*/
+interface ReceiveDirectOps {
+  /**
+  * Forwarded in the message meta; consumed by `AGateway` to route the
+  * request to a specific registry API version.
+  */
+  registryApiVersion?: string;
+  /**
+  * Override the target exchange. Defaults to the exchange resolved from the
+  * external queue configuration for the given event.
+  */
+  exchangeName?: ExchangeName;
+  /**
+  * Schema describing the **inner** `response` payload. The validator wraps
+  * it with the envelope shape (`event`, `payload.uuid`, `payload.error`,
+  * `meta.date`, etc.) automatically — so pass just the fields you expect
+  * inside `response`, not the envelope itself.
+  *
+  * Null is acceptable only for legacy use cases.
+  */
+  validationRules: ValidationSchema | null;
+  /** Bypass response caching on the subscriber side if configured. */
+  ignoreCache?: boolean;
+  /**
+  * Override the default direct-response timeout (ms). Falls back to the
+  * publisher's configured `directResponseTimeout` (10s by default).
+  */
+  timeout?: number;
+  /**
+  * Defaults to a freshly generated `randomUUID()` when omitted.
+  */
+  requestUuid?: string;
+}
+interface ExternalCommunicatorResponseError {
+  http_code: HttpStatusCode;
+  message?: string;
+  data?: Record<string, unknown>;
+}
+interface ExternalCommunicatorSuccessResponse<T> {
+  uuid: string;
+  response: T;
+  error: never;
+}
+interface ExternalCommunicatorFailureResponse {
+  uuid: string;
+  error?: ExternalCommunicatorResponseError;
+  response: never;
+}
+type ExternalCommunicatorResponse<T> = ExternalCommunicatorSuccessResponse<T> | ExternalCommunicatorFailureResponse;
+//#endregion
+export { ExternalCommunicatorFailureResponse, ExternalCommunicatorResponse, ExternalCommunicatorResponseError, ExternalCommunicatorSuccessResponse, ReceiveDirectOps };

package/dist/interfaces/index.d.ts

@@ -0,0 +1,95 @@
+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 { 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 { 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";
+import { ExternalCommunicatorFailureResponse, ExternalCommunicatorResponse, ExternalCommunicatorResponseError, ExternalCommunicatorSuccessResponse, ReceiveDirectOps } from "./externalCommunicator.js";
+import { ValidationError } from "@diia-inhouse/errors";
+import { ValidationSchema } from "@diia-inhouse/validators";
+
+//#region src/interfaces/index.d.ts
+type EventListeners = Partial<Record<EventName, EventBusListener>>;
+interface TaskQueue {
+  subscribe(queueName: QueueName, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
+  publish(taskName: string, message: MessagePayload, delay?: number): Promise<PublishingResult>;
+}
+interface ScheduledTasksQueue {
+  subscribe(queueName: QueueName, messageHandler: MessageHandler): Promise<boolean>;
+  publishToQueue(queueName: QueueName, payload: MessageData): Promise<PublishingResult>;
+  /** @deprecated
+  * - 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, serviceName: string): Promise<PublishingResult>;
+  publishToExchange(exchangeName: ExchangeName, routingKey: string, payload: MessageData): Promise<PublishingResult>;
+}
+interface EventBusQueue {
+  subscribe(queueName: QueueName, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
+  /** @deprecated
+  * - use the publishToExchange method for pushing a message by a routing key
+  * - use the publishToQueue method for pushing a message to a queue
+  * */
+  publish(publicationName: EventName, message: MessagePayload, options?: PublishOptions): Promise<PublishingResult>;
+  publishToQueue(queueName: QueueName, payload: MessageData): Promise<PublishingResult>;
+  publishToExchange(exchangeName: ExchangeName, routingKey: string, payload: MessageData): Promise<PublishingResult>;
+}
+interface ExternalEventBusQueue {
+  subscribe(queueName: QueueName, messageHandler: MessageHandler): Promise<boolean>;
+  /** @deprecated
+  * - 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>;
+  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>;
+}
+interface Listener {
+  queueNames?: string[];
+  nackOptions?: NackOptions;
+  validationRules?: ValidationSchema;
+  getServiceCode?(payload: unknown): string;
+}
+interface EventBusListener extends Listener {
+  event: EventName;
+  /** @deprecated use receive direct mechanism */
+  isSync?: boolean;
+  validationErrorHandler?(error: ValidationError, uuid: string): Promise<void>;
+  handler?(payload: unknown, meta: QueueMessageMetaData): Promise<unknown>;
+}
+interface TaskListener extends Listener {
+  name: string;
+  /**
+  * @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
+  */
+  isDelayed?: boolean;
+  handler(payload: unknown, meta: QueueMessageMetaData): Promise<void | NackOptions>;
+}
+type QueueConfig = RabbitMQConfig;
+interface InternalQueueConfig extends QueueConfig {
+  queueName?: string;
+  /**
+  * @deprecated use pkg-workflow entities instead
+  */
+  scheduledTaskQueueName?: string;
+}
+type QueueConnectionConfig = {
+  serviceRulesConfig: ServiceRulesConfig;
+  [QueueConnectionType.Internal]?: InternalQueueConfig;
+  [QueueConnectionType.External]?: QueueConfig;
+};
+interface MessageBrokerServiceListener {
+  handler: MessageHandler;
+  queueOptions: QueueOptions;
+  exchangesOptions: ExchangeOptions[];
+}
+interface MessageBrokerServiceEventsListener extends MessageBrokerServiceListener {
+  eventNames?: string[];
+}
+//#endregion
+export { EventBusListener, EventBusQueue, EventListeners, ExternalEventBusQueue, InternalQueueConfig, Listener, MessageBrokerServiceEventsListener, MessageBrokerServiceListener, QueueConfig, QueueConnectionConfig, ScheduledTasksQueue, TaskListener, TaskQueue };

package/dist/interfaces/index.js

@@ -1,30 +1,7 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const queueStatus_1 = require("./queueStatus");
-__exportStar(require("./providers/rabbitmq"), exports);
-__exportStar(require("./providers/rabbitmq/amqpConnection"), exports);
-__exportStar(require("./providers/rabbitmq/amqpPublisher"), exports);
-__exportStar(require("./queueStatus"), exports);
-__exportStar(require("./options"), exports);
-__exportStar(require("./messageHandler"), exports);
-__exportStar(require("./options"), exports);
-__exportStar(require("./queueContext"), exports);
-__exportStar(require("./messageBrokerServiceConfig"), exports);
-__exportStar(require("./metrics"), exports);
-__exportStar(require("./queueConfig"), exports);
-__exportStar(require("./externalCommunicator"), exports);
-//# sourceMappingURL=index.js.map
+import "./providers/rabbitmq/index.js";
+import "./providers/rabbitmq/amqpConnection.js";
+import "./queueStatus.js";
+import "./messageBrokerServiceConfig.js";
+import "./metrics/index.js";
+import "./queueConfig/configs.js";
+export {};

package/dist/interfaces/messageBrokerServiceConfig.d.ts

@@ -0,0 +1,80 @@
+import { Options } from "amqplib";
+
+//#region src/interfaces/messageBrokerServiceConfig.d.ts
+interface BaseBindOptions {
+  exchangeName: string;
+  routingKey?: string;
+}
+interface BindOptions extends BaseBindOptions {
+  bind?: boolean;
+}
+interface UnbindOptions extends BaseBindOptions {
+  unbind?: boolean;
+}
+interface RecreateChannelOptions {
+  timeout?: number;
+  maxTries?: number;
+  backoffCoefficient?: number;
+}
+interface ConsumerOptions {
+  consumerTag?: string;
+  prefetchCount?: number;
+  recreateChannelOptions?: RecreateChannelOptions;
+}
+type ExchangeName = string;
+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"
+}
+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[];
+}
+declare const MessageBrokerExternalServiceTypes: readonly ["externalEventBus"];
+type MessageBrokerExternalServiceType = (typeof MessageBrokerExternalServiceTypes)[number];
+declare const MessageBrokerInternalServiceTypes: readonly ["task", "eventBus", "scheduledTask"];
+type MessageBrokerInternalServiceType = (typeof MessageBrokerInternalServiceTypes)[number];
+declare const MessageBrokerGeneralServiceTypes: readonly ["general"];
+type MessageBrokerGeneralServiceType = (typeof MessageBrokerGeneralServiceTypes)[number];
+type MessageBrokerServiceType = MessageBrokerExternalServiceType | MessageBrokerInternalServiceType | MessageBrokerGeneralServiceType;
+interface MessageBrokerServiceConfig {
+  queuesOptions: QueueOptions[];
+  exchangesOptions: ExchangeOptions[];
+}
+declare const emptyMessageBrokerServiceConfig: MessageBrokerServiceConfig;
+type MessageBrokerServicesConfig = { [k in MessageBrokerServiceType]?: MessageBrokerServiceConfig };
+declare const QueueTypes: {
+  readonly Quorum: "quorum";
+  readonly Classic: "classic";
+};
+type QueueType = (typeof QueueTypes)[keyof typeof QueueTypes];
+interface BaseQueueOptions {
+  type?: QueueType;
+  options?: Options.AssertQueue;
+}
+interface RedeclareQueueOptions extends BaseQueueOptions {
+  redeclare?: boolean;
+}
+interface QueueOptions extends BaseQueueOptions {
+  name: string;
+  declare?: boolean;
+  bindTo: BindOptions[];
+  unbindFrom?: UnbindOptions[];
+  consumerOptions?: ConsumerOptions;
+  redeclareOptions?: RedeclareQueueOptions;
+}
+//#endregion
+export { BaseQueueOptions, BindOptions, ConsumerOptions, ExchangeName, ExchangeOptions, ExchangeType, MessageBrokerExternalServiceType, MessageBrokerExternalServiceTypes, MessageBrokerGeneralServiceType, MessageBrokerGeneralServiceTypes, MessageBrokerInternalServiceType, MessageBrokerInternalServiceTypes, MessageBrokerServiceConfig, MessageBrokerServiceType, MessageBrokerServicesConfig, QueueOptions, QueueTypes, RecreateChannelOptions, RedeclareQueueOptions, UnbindOptions, emptyMessageBrokerServiceConfig };

package/dist/interfaces/messageBrokerServiceConfig.js

@@ -1,26 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueTypes = exports.emptyMessageBrokerServiceConfig = exports.MessageBrokerGeneralServiceTypes = exports.MessageBrokerInternalServiceTypes = exports.MessageBrokerExternalServiceTypes = exports.ExchangeType = void 0;
-var ExchangeType;
-(function (ExchangeType) {
-    ExchangeType["Direct"] = "direct";
-    ExchangeType["Fanout"] = "fanout";
-    ExchangeType["Topic"] = "topic";
-    ExchangeType["Headers"] = "headers";
-    /**
-     * @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
-     */
-    ExchangeType["XDelayedMessage"] = "x-delayed-message";
-})(ExchangeType || (exports.ExchangeType = ExchangeType = {}));
-exports.MessageBrokerExternalServiceTypes = ['externalEventBus'];
-exports.MessageBrokerInternalServiceTypes = ['task', 'eventBus', 'scheduledTask'];
-exports.MessageBrokerGeneralServiceTypes = ['general'];
-exports.emptyMessageBrokerServiceConfig = {
-    queuesOptions: [],
-    exchangesOptions: [],
+//#region src/interfaces/messageBrokerServiceConfig.ts
+let ExchangeType = /* @__PURE__ */ function(ExchangeType) {
+	ExchangeType["Direct"] = "direct";
+	ExchangeType["Fanout"] = "fanout";
+	ExchangeType["Topic"] = "topic";
+	ExchangeType["Headers"] = "headers";
+	/**
+	* @deprecated the RabbitMQ plugin that supports delayed messages is deprecated and should be removed in the future
+	*/
+	ExchangeType["XDelayedMessage"] = "x-delayed-message";
+	return ExchangeType;
+}({});
+const MessageBrokerExternalServiceTypes = ["externalEventBus"];
+const MessageBrokerInternalServiceTypes = [
+	"task",
+	"eventBus",
+	"scheduledTask"
+];
+const MessageBrokerGeneralServiceTypes = ["general"];
+const emptyMessageBrokerServiceConfig = {
+	queuesOptions: [],
+	exchangesOptions: []
 };
-exports.QueueTypes = {
-    Quorum: 'quorum',
-    Classic: 'classic',
+const QueueTypes = {
+	Quorum: "quorum",
+	Classic: "classic"
 };
-//# sourceMappingURL=messageBrokerServiceConfig.js.map
+//#endregion
+export { ExchangeType, MessageBrokerExternalServiceTypes, MessageBrokerGeneralServiceTypes, MessageBrokerInternalServiceTypes, QueueTypes, emptyMessageBrokerServiceConfig };

package/dist/interfaces/messageHandler.d.ts

@@ -0,0 +1,6 @@
+import { QueueMessage } from "./providers/rabbitmq/index.js";
+
+//#region src/interfaces/messageHandler.d.ts
+type MessageHandler = (msg: QueueMessage) => Promise<void>;
+//#endregion
+export { MessageHandler };

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

@@ -0,0 +1,23 @@
+//#region src/interfaces/metrics/index.d.ts
+interface TotalListenerChannelErrorsLabelsMap {
+  queueName: string;
+}
+interface TotalMessageHandlerErrorsLabelsMap {
+  event: string;
+  serviceName: string;
+}
+declare const LabelUnknown = "unknown";
+type CommunicationDirection = ["inbound", "outbound"][number];
+declare class CommunicationsTotalLabelsMap {
+  event: string;
+  source: string;
+  queue?: string;
+  destination?: string;
+  direction: CommunicationDirection;
+}
+declare const communicationsTotalLabelsMap: (keyof CommunicationsTotalLabelsMap)[];
+declare const Metrics: {
+  readonly CommunicationsTotal: "diia_rabbitmq_communications_total";
+};
+//#endregion
+export { CommunicationDirection, CommunicationsTotalLabelsMap, LabelUnknown, Metrics, TotalListenerChannelErrorsLabelsMap, TotalMessageHandlerErrorsLabelsMap, communicationsTotalLabelsMap };

package/dist/interfaces/metrics/index.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Metrics = exports.communicationsTotalLabelsMap = exports.CommunicationsTotalLabelsMap = exports.LabelUnknown = void 0;
-exports.LabelUnknown = 'unknown';
-class CommunicationsTotalLabelsMap {
-    event = 'unknown';
-    source = 'unknown';
-    queue;
-    destination;
-    direction = 'inbound';
-}
-exports.CommunicationsTotalLabelsMap = CommunicationsTotalLabelsMap;
-exports.communicationsTotalLabelsMap = Object.keys(new CommunicationsTotalLabelsMap());
-exports.Metrics = {
-    CommunicationsTotal: 'diia_rabbitmq_communications_total',
+//#region src/interfaces/metrics/index.ts
+const LabelUnknown = "unknown";
+var CommunicationsTotalLabelsMap = class {
+	event = "unknown";
+	source = "unknown";
+	queue;
+	destination;
+	direction = "inbound";
 };
-//# sourceMappingURL=index.js.map
+const communicationsTotalLabelsMap = Object.keys(new CommunicationsTotalLabelsMap());
+const Metrics = { CommunicationsTotal: "diia_rabbitmq_communications_total" };
+//#endregion
+export { CommunicationsTotalLabelsMap, LabelUnknown, Metrics, communicationsTotalLabelsMap };

package/dist/interfaces/options.d.ts

@@ -0,0 +1,52 @@
+import { RecreateChannelOptions } from "./messageBrokerServiceConfig.js";
+import { Options } from "amqplib";
+
+//#region src/interfaces/options.d.ts
+interface PublisherOptions {
+  timeout?: number;
+  replyToQueueName?: string;
+}
+interface ListenerOptions {
+  queueOptions?: Options.AssertQueue;
+  prefetchCount?: number;
+  recreateChannelOptions?: RecreateChannelOptions;
+}
+interface PublishDirectOptions {
+  exchangeName?: string;
+  timeout?: number;
+  ignoreCache?: boolean;
+  registryApiVersion?: string;
+}
+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;
+}
+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;
+}
+interface PublishExternalEventOptions extends PublishOptions, PublishDirectOptions {}
+//#endregion
+export { ListenerOptions, PublishDirectOptions, PublishExternalEventOptions, PublishOptions, PublisherOptions, SubscribeOptions };

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

@@ -0,0 +1,33 @@
+import { Options } from "amqplib";
+
+//#region src/interfaces/providers/rabbitmq/amqpConnection.d.ts
+interface AmqpConfig {
+  protocol?: string;
+  hostname?: string;
+  port?: number;
+  username?: string;
+  password?: string;
+  heartbeat?: number;
+}
+type ConnectOptions = Options.Connect;
+interface SocketOptions {
+  clientProperties?: Record<string, unknown>;
+}
+interface ReconnectOptions {
+  reconnectEnabled?: boolean;
+  reconnectTimeout?: number;
+}
+declare enum ConnectionStatus {
+  Init = "init",
+  Connecting = "connecting",
+  Connected = "connected",
+  Reconnecting = "reconnecting",
+  Closing = "closing",
+  Closed = "closed",
+  Down = "down"
+}
+declare const AmqpConnectionEventNames: {
+  readonly Ready: "ready";
+};
+//#endregion
+export { AmqpConfig, AmqpConnectionEventNames, ConnectOptions, ConnectionStatus, ReconnectOptions, SocketOptions };