@diia-inhouse/diia-queue 7.3.0 → 13.2.0

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

@@ -1,24 +1,11 @@
-import { PubSubService } from '@diia-inhouse/redis';
-import { Logger, OnRegistrationsFinished } from '@diia-inhouse/types';
-import { EventBusListener, ExternalEventBusQueue } from '../interfaces';
-import { ReceiveDirectOps, ReceiveOps } from '../interfaces/externalCommunicator';
-import { EventName } from '../interfaces/queueConfig';
+import Logger from '@diia-inhouse/diia-logger';
+import { ExternalEventBusQueue } from '../interfaces';
+import { ReceiveDirectOps } from '../interfaces/externalCommunicator';
 import { EventMessageValidator } from './eventMessageValidator';
-import { ExternalCommunicatorChannel } from './externalCommunicatorChannel';
-export declare class ExternalCommunicator implements OnRegistrationsFinished {
-    private readonly externalChannel;
+export declare class ExternalCommunicator {
     private readonly externalEventBus;
-    private readonly externalEventListenerList;
     private readonly eventMessageValidator;
     private readonly logger;
-    private readonly pubsub;
-    private readonly timeout;
-    private eventListeners;
-    constructor(externalChannel: ExternalCommunicatorChannel, externalEventBus: ExternalEventBusQueue, externalEventListenerList: EventBusListener[], eventMessageValidator: EventMessageValidator, logger: Logger, pubsub: PubSubService, timeout?: number);
-    onRegistrationsFinished(): void;
-    receiveDirect<T>(event: string, request?: unknown, ops?: ReceiveDirectOps): Promise<T>;
-    /**
-     * @deprecated use receiveDirect in case provider supports direct communcation
-     */
-    receive<T>(event: EventName, request?: unknown, ops?: ReceiveOps): Promise<T | undefined>;
+    constructor(externalEventBus: ExternalEventBusQueue, eventMessageValidator: EventMessageValidator, logger: Logger);
+    receiveDirect<T>(event: string, request: unknown | undefined, ops: ReceiveDirectOps): Promise<T>;
 }

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

@@ -1,18 +1,33 @@
+import Logger from '@diia-inhouse/diia-logger';
 import { EnvService } from '@diia-inhouse/env';
-import { Logger, OnInit } from '@diia-inhouse/types';
-import { EventBusListener, ExternalEventBusQueue, MessageHandler, MessagePayload, PublishDirectOptions, PublishExternalEventOptions, SubscribeOptions } from '../interfaces';
-import { EventName, Topic } from '../interfaces/queueConfig';
+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 implements ExternalEventBusQueue, OnInit {
-    private readonly queueProvider;
-    private readonly externalEventListenerList;
-    private readonly eventMessageHandler;
+export declare class ExternalEventBus extends Communicator implements ExternalEventBusQueue, OnInit {
     private readonly envService;
-    private readonly logger;
-    constructor(queueProvider: RabbitMQProvider, externalEventListenerList: EventBusListener[], eventMessageHandler: EventMessageHandler, envService: EnvService, logger: Logger);
-    onInit(): Promise<void>;
-    subscribe(messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
-    publish(eventName: EventName, message: MessagePayload, options?: PublishExternalEventOptions): Promise<boolean>;
-    publishDirect<T>(eventName: EventName, message: MessagePayload, topic?: Topic, options?: PublishDirectOptions): Promise<T>;
+    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

@@ -2,8 +2,8 @@ export * from './eventBus';
 export * from './eventMessageHandler';
 export * from './eventMessageValidator';
 export * from './externalCommunicator';
-export * from './externalCommunicatorChannel';
 export * from './externalEventBus';
 export * from './scheduledTask';
 export * from './task';
 export * from './queue';
+export * from './metrics';

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

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

@@ -0,0 +1,10 @@
+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,18 +1,23 @@
-/// <reference types="node" />
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { HealthCheckResult, Logger, OnHealthCheck } from '@diia-inhouse/types';
-import { QueueConnectionConfig, QueueContext } from '../interfaces';
+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 serviceName;
+    private readonly systemServiceName;
+    private readonly metrics;
     private readonly connectionConfig;
     private readonly asyncLocalStorage;
     private readonly logger;
-    private internalQueue;
-    private externalQueue;
-    constructor(serviceName: string, connectionConfig: QueueConnectionConfig, asyncLocalStorage: AsyncLocalStorage<QueueContext>, logger: Logger);
+    private readonly internalRabbitMQProvidersMap;
+    private readonly externalRabbitMQProvidersMap;
+    constructor(systemServiceName: string, metrics: MetricsService, connectionConfig: QueueConnectionConfig, asyncLocalStorage: AsyncLocalStorage<QueueContext>, logger: Logger);
     onHealthCheck(): Promise<HealthCheckResult<QueueStatus>>;
-    getInternalQueue(): RabbitMQProvider;
-    getExternalQueue(): RabbitMQProvider;
+    makeInternalRabbitMQProvider(serviceType: MessageBrokerInternalServiceType): RabbitMQProvider;
+    makeExternalRabbitMQProvider(serviceType: MessageBrokerExternalServiceType): RabbitMQProvider;
+    private getProvidersStatus;
+    private getProvidersStatusDetails;
+    private getMessageBrokerServiceConfig;
 }

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

@@ -1,17 +1,25 @@
-import { Logger, OnInit } from '@diia-inhouse/types';
-import { EventBusListener, MessageHandler, ScheduledTasksQueue, SubscribeOptions } from '../interfaces';
-import { EventName, QueueName } from '../interfaces/queueConfig';
+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';
-export declare class ScheduledTask implements ScheduledTasksQueue, OnInit {
-    private readonly queueProvider;
-    private readonly scheduledTaskList;
-    private readonly eventMessageHandler;
-    private readonly logger;
-    private readonly queueName;
-    private readonly routingPart;
-    constructor(queueProvider: RabbitMQProvider, scheduledTaskList: EventBusListener[], eventMessageHandler: EventMessageHandler, logger: Logger, queueName: QueueName | undefined);
-    onInit(): Promise<void>;
-    subscribe(subscriptionName: QueueName, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
-    publish(scheduledTaskName: EventName, serviceName: string): Promise<boolean>;
+/**
+ * @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,18 +1,28 @@
-import { Logger, OnInit } from '@diia-inhouse/types';
-import { MessageHandler, MessagePayload, SubscribeOptions, TaskListener, TaskQueue } from '../interfaces';
+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 implements TaskQueue, OnInit {
-    private readonly queueProvider;
+export declare class Task extends Communicator implements TaskQueue, OnInit {
+    private readonly serviceName;
     private readonly taskList;
     private readonly eventMessageHandler;
-    private readonly logger;
-    constructor(queueProvider: RabbitMQProvider, taskList: TaskListener[], eventMessageHandler: EventMessageHandler, logger: Logger);
-    private readonly tasksMap;
+    private queueNamePrefix;
+    private taskNameExchangesOptionsMap;
+    constructor(serviceName: string, systemServiceName: string, queueProvider: RabbitMQProvider, taskList: TaskListener[], eventMessageHandler: EventMessageHandler, logger: Logger, hostName: string);
     onInit(): Promise<void>;
-    subscribe(taskName: string, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
-    publish(taskName: string, payload: MessagePayload, delay?: number): Promise<boolean>;
-    private subscribeTask;
-    private getTaskQueueName;
+    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 +1,3 @@
-import { EventBusListener } from './interfaces';
-import { EventListeners } from './interfaces/externalCommunicator';
+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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectEventBusListeners = void 0;
+exports.collectEventBusListeners = collectEventBusListeners;
+exports.getConsumerTag = getConsumerTag;
 function collectEventBusListeners(eventBusListeners) {
     const eventListeners = {};
     for (const listener of eventBusListeners) {
@@ -8,5 +9,7 @@ function collectEventBusListeners(eventBusListeners) {
     }
     return eventListeners;
 }
-exports.collectEventBusListeners = collectEventBusListeners;
+function getConsumerTag(serviceName, hostname) {
+    return `${serviceName}:${hostname}`;
+}
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;;AAGA,SAAgB,wBAAwB,CAAC,iBAAqC;IAC1E,MAAM,cAAc,GAAmB,EAAE,CAAA;IAEzC,KAAK,MAAM,QAAQ,IAAI,iBAAiB,EAAE;QACtC,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAA;KAC5C;IAED,OAAO,cAAc,CAAA;AACzB,CAAC;AARD,4DAQC"}
+{"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@diia-inhouse/diia-queue",
-    "version": "7.3.0",
+    "version": "13.2.0",
     "description": "Package provide queue functionality",
     "main": "dist/index.js",
     "types": "dist/types/index.d.ts",
@@ -8,65 +8,64 @@
     "author": "Diia",
     "license": "SEE LICENSE IN LICENSE.md",
     "engines": {
-        "node": ">=18"
+        "node": ">=22"
     },
     "files": [
         "dist"
     ],
     "scripts": {
         "build": "rimraf dist/ && tsc",
-        "start": "node dist/index.js",
-        "lint": "eslint --ext .ts . && prettier --check .",
-        "lint-fix": "eslint --ext .ts --fix && prettier --write .",
+        "build-watch": "tsc --watch",
+        "lint": "eslint . && prettier --check .",
+        "lint-fix": "eslint . --fix && prettier --write .",
         "lint:lockfile": "lockfile-lint --path package-lock.json --allowed-hosts registry.npmjs.org --validate-https",
         "format": "prettier --write \"src/**/*.ts\"",
         "prepare": "npm run build",
         "semantic-release": "semantic-release",
-        "test": "jest",
-        "test:integration": "npm run test --selectProjects integration --",
-        "test:unit": "npm run test --selectProjects unit --",
-        "test:coverage": "npm run test --selectProjects unit --coverage",
+        "test": "vitest run",
+        "test:watch": "vitest watch",
         "find-circulars": "madge --circular --extensions ts ./"
     },
     "dependencies": {
-        "@diia-inhouse/env": "1.16.0",
-        "@types/amqplib": "0.10.4",
-        "amqplib": "0.10.3",
-        "lodash": "4.17.21",
-        "p-timeout": "4.1.0",
-        "uuid": "9.0.1"
+        "@types/amqplib": "0.10.8",
+        "amqplib": "0.10.9",
+        "lodash": "4.17.23",
+        "p-timeout": "4.1.0"
     },
     "peerDependencies": {
-        "@diia-inhouse/diia-metrics": ">=3.6.0",
+        "@diia-inhouse/diia-logger": ">=3.1.0",
+        "@diia-inhouse/diia-metrics": ">=5.0.0",
+        "@diia-inhouse/env": ">=2.0.0",
         "@diia-inhouse/errors": ">=1.4.0",
-        "@diia-inhouse/redis": ">=2.1.1",
-        "@diia-inhouse/types": ">=5.0.0",
+        "@diia-inhouse/types": ">=6.30.0",
         "@diia-inhouse/utils": ">=2.21.0",
         "@diia-inhouse/validators": ">=1.5.0",
         "@opentelemetry/api": ">=1.7.0"
     },
     "devDependencies": {
-        "@diia-inhouse/configs": "1.31.1",
-        "@diia-inhouse/crypto": "1.11.0",
-        "@diia-inhouse/diia-logger": "2.15.0",
-        "@diia-inhouse/diia-metrics": "3.11.0",
-        "@diia-inhouse/errors": "1.9.0",
-        "@diia-inhouse/eslint-config": "5.1.0",
-        "@diia-inhouse/eslint-plugin": "1.6.0",
-        "@diia-inhouse/redis": "2.12.0",
-        "@diia-inhouse/test": "6.3.0",
-        "@diia-inhouse/types": "6.24.0",
-        "@diia-inhouse/utils": "3.5.0",
-        "@diia-inhouse/validators": "1.17.0",
-        "@opentelemetry/api": "1.7.0",
-        "@types/lodash": "4.14.202",
-        "@types/node": "20.11.5",
-        "@types/uuid": "9.0.7",
-        "glob": "10.3.10",
-        "lockfile-lint": "4.12.1",
-        "madge": "6.1.0",
-        "protobufjs": "7.2.5",
-        "type-fest": "4.8.2"
+        "@diia-inhouse/configs": "6.1.1",
+        "@diia-inhouse/diia-logger": "3.16.0",
+        "@diia-inhouse/diia-metrics": "6.4.0",
+        "@diia-inhouse/errors": "1.17.0",
+        "@diia-inhouse/eslint-config": "8.3.0",
+        "@diia-inhouse/eslint-plugin": "1.9.5",
+        "@diia-inhouse/test": "7.2.0",
+        "@diia-inhouse/types": "11.3.0",
+        "@diia-inhouse/utils": "5.3.0",
+        "@diia-inhouse/validators": "1.28.0",
+        "@opentelemetry/api": "1.9.0",
+        "@types/lodash": "4.17.24",
+        "@types/node": "24.11.0",
+        "@vitest/coverage-v8": "4.0.18",
+        "@vitest/ui": "4.0.18",
+        "lockfile-lint": "4.14.1",
+        "madge": "8.0.0",
+        "prettier": "3.8.1",
+        "rimraf": "6.1.3",
+        "type-fest": "4.41.0",
+        "vite-tsconfig-paths": "6.1.1",
+        "vitest": "4.0.18",
+        "vitest-mock-extended": "3.1.0"
     },
     "release": {
         "extends": "@diia-inhouse/configs/dist/semantic-release/package"
@@ -76,11 +75,6 @@
     },
     "eslintConfig": {
         "extends": "@diia-inhouse/eslint-config",
-        "rules": {
-            "@typescript-eslint/no-unnecessary-condition": [
-                "off"
-            ]
-        },
         "overrides": [
             {
                 "files": [
@@ -95,9 +89,6 @@
             }
         ]
     },
-    "jest": {
-        "preset": "@diia-inhouse/configs/dist/jest"
-    },
     "prettier": "@diia-inhouse/eslint-config/prettier",
     "madge": {
         "tsConfig": "./tsconfig.json"

package/dist/interfaces/providers/rabbitmq/amqpListener.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"amqpListener.js","sourceRoot":"","sources":["../../../../src/interfaces/providers/rabbitmq/amqpListener.ts"],"names":[],"mappings":""}

package/dist/services/externalCommunicatorChannel.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalCommunicatorChannel = void 0;
-class ExternalCommunicatorChannel {
-    cache;
-    constructor(cache) {
-        this.cache = cache;
-    }
-    getChannel(event, requestUuid) {
-        this.assertChannelAvailability();
-        return `external_communicator_channel_${event}_${requestUuid}`;
-    }
-    async isChannelActive(channel) {
-        this.assertChannelAvailability();
-        return Boolean(await this.cache.get(this.getActiveChannelKey(channel)));
-    }
-    async saveActiveChannel(channel, timeout) {
-        this.assertChannelAvailability();
-        await this.cache.set(this.getActiveChannelKey(channel), 'true', Math.floor(timeout / 1000));
-    }
-    getActiveChannelKey(channel) {
-        return `active_${channel}`;
-    }
-    assertChannelAvailability() {
-        if (!this.cache) {
-            throw new Error('Cache service is not provided for the ExternalCommunicatorChannel service');
-        }
-    }
-}
-exports.ExternalCommunicatorChannel = ExternalCommunicatorChannel;
-//# sourceMappingURL=externalCommunicatorChannel.js.map

package/dist/services/externalCommunicatorChannel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"externalCommunicatorChannel.js","sourceRoot":"","sources":["../../src/services/externalCommunicatorChannel.ts"],"names":[],"mappings":";;;AAIA,MAAa,2BAA2B;IACP;IAA7B,YAA6B,KAA+B;QAA/B,UAAK,GAAL,KAAK,CAA0B;IAAG,CAAC;IAEhE,UAAU,CAAC,KAAgB,EAAE,WAAmB;QAC5C,IAAI,CAAC,yBAAyB,EAAE,CAAA;QAEhC,OAAO,iCAAiC,KAAK,IAAI,WAAW,EAAE,CAAA;IAClE,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,OAAe;QACjC,IAAI,CAAC,yBAAyB,EAAE,CAAA;QAEhC,OAAO,OAAO,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IAC3E,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,OAAe,EAAE,OAAe;QACpD,IAAI,CAAC,yBAAyB,EAAE,CAAA;QAEhC,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAA;IAC/F,CAAC;IAEO,mBAAmB,CAAC,OAAe;QACvC,OAAO,UAAU,OAAO,EAAE,CAAA;IAC9B,CAAC;IAEO,yBAAyB;QAC7B,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YACb,MAAM,IAAI,KAAK,CAAC,2EAA2E,CAAC,CAAA;SAC/F;IACL,CAAC;CACJ;AA9BD,kEA8BC"}

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

@@ -1,7 +0,0 @@
-import { Channel, Options } from 'amqplib';
-import { QueueMessage } from '.';
-export interface QueueChannelAndOptions {
-    channel: Channel;
-    queueOptions: Options.AssertQueue;
-}
-export type QueueCallback = (msg: QueueMessage | null) => unknown;

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

@@ -1,11 +0,0 @@
-import { CacheService } from '@diia-inhouse/redis';
-import { EventName } from '../interfaces/queueConfig';
-export declare class ExternalCommunicatorChannel {
-    private readonly cache;
-    constructor(cache: CacheService | undefined);
-    getChannel(event: EventName, requestUuid: string): string;
-    isChannelActive(channel: string): Promise<boolean>;
-    saveActiveChannel(channel: string, timeout: number): Promise<void>;
-    private getActiveChannelKey;
-    private assertChannelAvailability;
-}