@diia-inhouse/diia-queue 13.3.4 → 14.0.11

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

@@ -1,20 +0,0 @@
-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 { EventName, QueueName } from '../interfaces/queueConfig';
-import { RabbitMQProvider } from '../providers/rabbitmq';
-import Communicator from './communicator';
-import { EventMessageHandler } from './eventMessageHandler';
-export declare class EventBus extends Communicator implements EventBusQueue, OnInit {
-    private readonly eventListenerList;
-    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

@@ -1,15 +0,0 @@
-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,19 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import Logger from '@diia-inhouse/diia-logger';
-import { EventBusListener, EventListeners, QueueContext, QueueMessage, TaskListener } from '../interfaces';
-import { EventMessageValidator } from './eventMessageValidator';
-export declare class EventMessageHandler {
-    private readonly eventMessageValidator;
-    private readonly asyncLocalStorage;
-    private readonly 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 prepareAsyncContext;
-    private handleMessage;
-    private validateData;
-    private directReplyDone;
-    private getServiceCode;
-    private prepareQueueMessageError;
-}

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

@@ -1,9 +0,0 @@
-import { AppValidator, ValidationSchema } from '@diia-inhouse/validators';
-import { QueueMessageData } from '../interfaces/providers/rabbitmq';
-export declare class EventMessageValidator {
-    private readonly validator;
-    readonly metaValidationSchema: ValidationSchema;
-    constructor(validator: AppValidator);
-    validateEventMessage(data: QueueMessageData, payloadValidationSchema?: ValidationSchema): void | never;
-    validateSyncedEventMessage(data: QueueMessageData, responseValidationSchema?: ValidationSchema): void | never;
-}

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

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

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

@@ -1,33 +0,0 @@
-import Logger from '@diia-inhouse/diia-logger';
-import { EnvService } from '@diia-inhouse/env';
-import { OnInit } from '@diia-inhouse/types';
-import { EventBusListener, ExternalEventBusQueue, MessageBrokerServiceEventsListener, MessagePayload, PublishDirectOptions, PublishOptions, PublishingResult } from '../interfaces';
-import { ExchangeName, ExchangeOptions } from '../interfaces/messageBrokerServiceConfig';
-import { EventName } from '../interfaces/queueConfig';
-import { RabbitMQProvider } from '../providers/rabbitmq';
-import Communicator from './communicator';
-import { EventMessageHandler } from './eventMessageHandler';
-export declare class ExternalEventBus extends Communicator implements ExternalEventBusQueue, OnInit {
-    private readonly envService;
-    private readonly eventCommunicator;
-    private readonly publishEventsSet;
-    private readonly subscribeEventsSet;
-    private readonly exchangePrefixName;
-    private readonly eventQueueMap;
-    constructor(logger: Logger, systemServiceName: string, envService: EnvService, queueProvider: RabbitMQProvider, externalEventListenerList: EventBusListener[], eventMessageHandler: EventMessageHandler, hostName: string);
-    static BuildRequestRoutingKey(eventName: string): string;
-    static BuildResponseRoutingKey(eventName: EventName, portalEvents?: string[]): string;
-    private static prepareQueuePrefix;
-    publish(eventName: EventName, payload: MessagePayload, options?: PublishOptions): Promise<PublishingResult>;
-    publishDirect<T>(eventName: EventName, payload: MessagePayload, options?: PublishDirectOptions): Promise<T>;
-    protected getUnicastListeners(): MessageBrokerServiceEventsListener[];
-    protected getExchangeNameWithSuffix(topic: ExchangeName): string;
-    protected getProducerExchangesOptions(): ExchangeOptions[];
-    protected getMulticastListeners(): MessageBrokerServiceEventsListener[];
-    private getPublishMessage;
-    private getPublishRoutingKey;
-    private defineQueuesAndExchangesOptionsBasedOnGlobalConfig;
-    private buildEventQueueMap;
-    private buildResponseQueueName;
-    private buildRequestQueueName;
-}

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

@@ -1,9 +0,0 @@
-export * from './eventBus';
-export * from './eventMessageHandler';
-export * from './eventMessageValidator';
-export * from './externalCommunicator';
-export * from './externalEventBus';
-export * from './scheduledTask';
-export * from './task';
-export * from './queue';
-export * from './metrics';

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

@@ -1,11 +0,0 @@
-import { MetricsService } from '@diia-inhouse/diia-metrics';
-import { ErrorType } from '@diia-inhouse/errors';
-import { CommunicationDirection } from '../interfaces/metrics';
-export default class RabbitMQMetricsService {
-    private metrics;
-    private readonly communicationsTotalMetric;
-    constructor(metrics: MetricsService);
-    collectResponseTotalMetric(startTime: bigint, route: string, source: string, destination: string, errorType?: ErrorType): void | never;
-    collectCommunicationsTotalMetric(event: string, source: string, destination: string, direction: CommunicationDirection, queue?: string): void;
-    collectRequestTotalMetric(startTime: bigint, route: string, source: string, destination: string, errorType?: ErrorType): void;
-}

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

@@ -1,10 +0,0 @@
-import { ConsumerOptions, ExchangeName, QueueOptions } from '../interfaces/messageBrokerServiceConfig';
-import { QueueName } from '../interfaces/queueConfig';
-import { RabbitMQProvider } from '../providers/rabbitmq';
-export default class OptionsBuilder {
-    private readonly queueProvider;
-    constructor(queueProvider: RabbitMQProvider);
-    defineQueueOptionsBasedOnGlobalConfig(queueName?: QueueName, routingKey?: string): QueueOptions[];
-    defineConsumerOptionsBasedOnGlobalConfig(): ConsumerOptions;
-    getExchangeNamesByQueueName(queueName?: QueueName): ExchangeName[];
-}

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

@@ -1,23 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import Logger from '@diia-inhouse/diia-logger';
-import { MetricsService } from '@diia-inhouse/diia-metrics';
-import { HealthCheckResult, OnHealthCheck } from '@diia-inhouse/types';
-import { MessageBrokerExternalServiceType, MessageBrokerInternalServiceType, QueueConnectionConfig, QueueContext } from '../interfaces';
-import { QueueStatus } from '../interfaces/queueStatus';
-import { RabbitMQProvider } from '../providers/rabbitmq';
-export declare class Queue implements OnHealthCheck {
-    private readonly systemServiceName;
-    private readonly metrics;
-    private readonly connectionConfig;
-    private readonly asyncLocalStorage;
-    private readonly logger;
-    private readonly internalRabbitMQProvidersMap;
-    private readonly externalRabbitMQProvidersMap;
-    constructor(systemServiceName: string, metrics: MetricsService, connectionConfig: QueueConnectionConfig, asyncLocalStorage: AsyncLocalStorage<QueueContext>, logger: Logger);
-    onHealthCheck(): Promise<HealthCheckResult<QueueStatus>>;
-    makeInternalRabbitMQProvider(serviceType: MessageBrokerInternalServiceType): RabbitMQProvider;
-    makeExternalRabbitMQProvider(serviceType: MessageBrokerExternalServiceType): RabbitMQProvider;
-    private getProvidersStatus;
-    private getProvidersStatusDetails;
-    private getMessageBrokerServiceConfig;
-}

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

@@ -1,25 +0,0 @@
-import Logger from '@diia-inhouse/diia-logger';
-import { OnInit } from '@diia-inhouse/types';
-import { EventBusListener, ExchangeName, MessageBrokerServiceEventsListener, PublishingResult, ScheduledTasksQueue } from '../interfaces';
-import { ExchangeOptions } from '../interfaces/messageBrokerServiceConfig';
-import { QueueName } from '../interfaces/queueConfig';
-import { RabbitMQProvider } from '../providers/rabbitmq';
-import Communicator from './communicator';
-import { EventMessageHandler } from './eventMessageHandler';
-/**
- * @deprecated use pkg-workflow entities instead
- */
-export declare class ScheduledTask extends Communicator implements ScheduledTasksQueue, OnInit {
-    private readonly serviceName;
-    protected readonly scheduledTaskList: EventBusListener[];
-    private readonly queueName?;
-    private readonly eventCommunicator;
-    private readonly eventRoutingPart;
-    constructor(serviceName: string, systemServiceName: string, queueProvider: RabbitMQProvider, scheduledTaskList: EventBusListener[], eventMessageHandler: EventMessageHandler, logger: Logger, hostName: string, queueName?: QueueName | undefined);
-    publish(eventName: string, serviceName: string): Promise<PublishingResult>;
-    protected getExchangeNameWithSuffix(exchangeName: ExchangeName): string;
-    protected getUnicastListeners(): MessageBrokerServiceEventsListener[];
-    protected getMulticastListeners(): MessageBrokerServiceEventsListener[];
-    protected getProducerExchangesOptions(): ExchangeOptions[];
-    private getRoutingKey;
-}

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

@@ -1,28 +0,0 @@
-import Logger from '@diia-inhouse/diia-logger';
-import { OnInit } from '@diia-inhouse/types';
-import { MessageBrokerServiceListener, MessagePayload, PublishingResult, TaskListener, TaskQueue } from '../interfaces';
-import { ExchangeOptions } from '../interfaces/messageBrokerServiceConfig';
-import { RabbitMQProvider } from '../providers/rabbitmq';
-import Communicator from './communicator';
-import { EventMessageHandler } from './eventMessageHandler';
-export declare class Task extends Communicator implements TaskQueue, OnInit {
-    private readonly serviceName;
-    private readonly taskList;
-    private readonly eventMessageHandler;
-    private queueNamePrefix;
-    private taskNameExchangesOptionsMap;
-    constructor(serviceName: string, systemServiceName: string, queueProvider: RabbitMQProvider, taskList: TaskListener[], eventMessageHandler: EventMessageHandler, logger: Logger, hostName: string);
-    onInit(): Promise<void>;
-    publish(taskName: string, payload: MessagePayload, delay?: number): Promise<PublishingResult>;
-    protected getProducerExchangesOptions(): ExchangeOptions[];
-    protected getMulticastListeners(): MessageBrokerServiceListener[];
-    protected getUnicastListeners(): MessageBrokerServiceListener[];
-    protected getExchangeNameWithSuffix(taskName: string): string;
-    private defineExchangesOptions;
-    private defineQueueOptionsBasedOnGlobalConfig;
-    private defineExchangesOptionsBasedOnGlobalConfig;
-    private defineConsumerOptionsBasedOnGlobalConfig;
-    private getQueueName;
-    private capitalizeFirstLetter;
-    private defineQueueNameByTaskName;
-}

package/dist/types/utils.d.ts

@@ -1,3 +0,0 @@
-import { EventBusListener, EventListeners } from './interfaces';
-export declare function collectEventBusListeners(eventBusListeners: EventBusListener[]): EventListeners;
-export declare function getConsumerTag(serviceName: string, hostname: string): string;

package/dist/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;AAEA,4DAQC;AAED,wCAEC;AAZD,SAAgB,wBAAwB,CAAC,iBAAqC;IAC1E,MAAM,cAAc,GAAmB,EAAE,CAAA;IAEzC,KAAK,MAAM,QAAQ,IAAI,iBAAiB,EAAE,CAAC;QACvC,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAA;IAC7C,CAAC;IAED,OAAO,cAAc,CAAA;AACzB,CAAC;AAED,SAAgB,cAAc,CAAC,WAAmB,EAAE,QAAgB;IAChE,OAAO,GAAG,WAAW,IAAI,QAAQ,EAAE,CAAA;AACvC,CAAC"}