@diia-inhouse/diia-queue 7.3.0

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

@@ -0,0 +1,26 @@
+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"
+}

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

@@ -0,0 +1,7 @@
+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/interfaces/providers/rabbitmq/amqpPublisher.d.ts

@@ -0,0 +1,24 @@
+import { PublishDirectOptions } from '../../index';
+import { EventName } from '../../queueConfig';
+export declare enum ExchangeType {
+    Direct = "direct",
+    Fanout = "fanout",
+    Topic = "topic",
+    Headers = "headers",
+    XDelayedMessage = "x-delayed-message"
+}
+export type MessagePayload = unknown;
+export interface MessageHeaders {
+    traceId: string;
+    serviceCode?: string;
+    'x-delay'?: number;
+}
+export interface PublishToExchangeParams {
+    eventName: EventName | string;
+    message: MessagePayload;
+    exchangeName: string;
+    routingKey?: string;
+    responseRoutingKey?: string;
+    headers: MessageHeaders;
+    options?: PublishDirectOptions;
+}

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

@@ -0,0 +1,50 @@
+import * as amqp from 'amqplib';
+import { ListenerOptions } from '../..';
+import { AmqpConnection } from '../../../providers/rabbitmq/amqpConnection';
+import { EventName } from '../../queueConfig';
+import { ConnectOptions, ConnectionStatus, ReconnectOptions, SocketOptions } from './amqpConnection';
+export * from './amqpConnection';
+export * from './amqpPublisher';
+export interface RabbitMQConfigCustomParams {
+    responseRoutingKeyPrefix?: string;
+}
+export interface RabbitMQConfig {
+    connection: ConnectOptions;
+    socketOptions?: SocketOptions;
+    reconnectOptions?: ReconnectOptions;
+    custom?: RabbitMQConfigCustomParams;
+    assertExchanges?: boolean;
+    listenerOptions: ListenerOptions;
+}
+export declare enum ConnectionClientType {
+    Listener = "listener",
+    Publisher = "publisher"
+}
+export type ConnectionList = {
+    [k in ConnectionClientType]: {
+        lock?: Promise<AmqpConnection>;
+    };
+};
+export interface QueueMessageMetaData {
+    date: Date;
+    xid?: string;
+    responseRoutingKey?: string;
+    ignoreCache?: boolean;
+}
+export interface QueueMessageData<T = any> {
+    event: EventName | string;
+    payload: T;
+    meta: QueueMessageMetaData;
+}
+export type MessageProperties = amqp.MessageProperties;
+export interface QueueMessage {
+    id?: unknown;
+    data: QueueMessageData;
+    properties: MessageProperties;
+    done: (data?: unknown) => void;
+    reject: () => void;
+}
+export interface RabbitMQStatus {
+    listener: ConnectionStatus;
+    publisher: ConnectionStatus;
+}

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

@@ -0,0 +1,39 @@
+export type EventName = string;
+export type QueueName = string;
+export type Topic = string;
+export declare enum QueueConfigType {
+    Internal = "internal",
+    External = "external"
+}
+export interface InternalServiceConfig {
+    subscribe?: QueueName[];
+    publish?: Topic[];
+}
+export interface ExternalServiceConfig {
+    publish: EventName[];
+    subscribe: EventName[];
+}
+export type ServiceConfigByConfigType = InternalServiceConfig | ExternalServiceConfig;
+export interface ServiceConfig {
+    [QueueConfigType.Internal]: InternalServiceConfig;
+    [QueueConfigType.External]: ExternalServiceConfig;
+}
+export type QueueConfigByQueueName = {
+    [k in QueueName]?: {
+        topics: Topic[];
+    };
+};
+export type QueueConfig = Record<QueueConfigType.Internal, QueueConfigByQueueName>;
+export type TopicConfigByConfigType = {
+    [k in Topic]?: {
+        events: EventName[];
+    };
+};
+export type TopicConfig = Record<QueueConfigType, TopicConfigByConfigType>;
+export type ServiceRulesConfig = {
+    servicesConfig: ServiceConfig;
+    topicsConfig: TopicConfig;
+    queuesConfig: QueueConfig;
+    portalEvents: EventName[];
+    internalEvents: EventName[];
+};

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

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

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

@@ -0,0 +1,6 @@
+import { RabbitMQStatus } from './providers/rabbitmq';
+import { QueueConnectionType } from '.';
+export type QueueStatusByType = Partial<Record<QueueConnectionType, RabbitMQStatus>>;
+export type QueueStatus = {
+    rabbit: QueueStatusByType;
+};

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

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

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+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, socketOptions?: SocketOptions);
+    connect(): Promise<void>;
+    /**
+     * Create new channel
+     */
+    createChannel(queueName: string): Promise<Channel>;
+    reconnect(): Promise<void>;
+    closeConnection(): Promise<void>;
+    getStatus(): ConnectionStatus;
+}

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

@@ -0,0 +1,26 @@
+import { Options, Replies } from 'amqplib';
+import { Logger } from '@diia-inhouse/types';
+import { ConnectionStatus, ListenerOptions } from '../../interfaces';
+import { QueueCallback } from '../../interfaces/providers/rabbitmq/amqpListener';
+import { AmqpConnection } from './amqpConnection';
+export declare class AmqpListener {
+    private connection;
+    private readonly logger;
+    private readonly options?;
+    private queuesChannels;
+    private queueCallback;
+    constructor(connection: AmqpConnection, logger: Logger, options?: ListenerOptions);
+    init(): Promise<void>;
+    listenQueue(queueName: string, callback: QueueCallback, queueOptions?: Options.AssertQueue): Promise<void | never>;
+    bindQueueToExchange(queueName: string, exchangeName: string, routingKey?: string): Promise<Replies.Empty>;
+    getStatus(): ConnectionStatus;
+    private ackMsg;
+    private nackMsg;
+    private createChannelAndListenQueue;
+    private saveQueueCallback;
+    private getQueueCallback;
+    private getChannel;
+    private getQueueOptions;
+    private saveChannel;
+    private onMessageCallback;
+}

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

@@ -0,0 +1,25 @@
+import { Options, Replies } from 'amqplib';
+import { Logger } from '@diia-inhouse/types';
+import { ConnectionStatus, ExchangeType } from '../../interfaces';
+import { PublishToExchangeParams } from '../../interfaces/providers/rabbitmq/amqpPublisher';
+import { AmqpConnection } from './amqpConnection';
+export declare class AmqpPublisher {
+    private readonly connection;
+    private readonly logger;
+    private readonly timeout;
+    readonly defaultExchangeType: ExchangeType;
+    private channel;
+    private eventEmitter;
+    private readonly defaultExchangeOptions;
+    constructor(connection: AmqpConnection, logger: Logger, timeout?: number);
+    init(): Promise<void>;
+    private createChannel;
+    publishToExchange(params: PublishToExchangeParams): Promise<boolean>;
+    publishToExchangeDirect<T>(params: PublishToExchangeParams): Promise<T>;
+    private static prepareQueueMessageData;
+    private publishDirect;
+    private publish;
+    private static defaultPublishOptions;
+    checkExchange(exchangeName: string, exchangeType?: ExchangeType, options?: Options.AssertExchange): Promise<Replies.AssertExchange>;
+    getStatus(): ConnectionStatus;
+}

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

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { type AsyncLocalStorage } from 'node:async_hooks';
+import { EventEmitter } from 'node:events';
+import { Logger } from '@diia-inhouse/types';
+import { ListenerOptions, MessageHandler, MessagePayload, PublishDirectOptions, PublishExternalEventOptions, PublishInternalEventOptions, QueueContext, RabbitMQConfig, RabbitMQStatus, SubscribeOptions } from '../../interfaces';
+import { EventName, QueueConfigByQueueName, QueueConfigType, QueueName, ServiceConfigByConfigType, Topic, TopicConfigByConfigType } from '../../interfaces/queueConfig';
+export declare class RabbitMQProvider extends EventEmitter {
+    private readonly serviceName;
+    private readonly rabbitmqConfig;
+    private readonly serviceConfig;
+    private readonly topicsConfig;
+    private readonly portalEvents;
+    private readonly internalEvents;
+    private readonly type;
+    private readonly logger;
+    private readonly asyncLocalStorage?;
+    private readonly queuesConfig?;
+    private initializingLock?;
+    private listener;
+    private publisher;
+    private connectionList;
+    private readonly projectName;
+    private readonly portalName;
+    private eventNameToTopicMap;
+    private externalPublishEventsSet;
+    private externalSubscribeEventsSet;
+    private assertExternalExchanges?;
+    constructor(serviceName: string, rabbitmqConfig: RabbitMQConfig, serviceConfig: ServiceConfigByConfigType, topicsConfig: TopicConfigByConfigType, portalEvents: EventName[], internalEvents: EventName[], type: QueueConfigType, logger: Logger, asyncLocalStorage?: AsyncLocalStorage<QueueContext>, queuesConfig?: QueueConfigByQueueName);
+    getServiceName(): string;
+    getConfig(): RabbitMQConfig;
+    init(listenerOptions?: ListenerOptions): Promise<void>;
+    subscribe(subscriptionName: QueueName, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
+    publish(eventName: EventName, message: MessagePayload, options?: PublishInternalEventOptions): Promise<boolean>;
+    subscribeTask(queueName: string, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
+    publishTask(queueName: string, message: MessagePayload, delay?: number): Promise<boolean>;
+    subscribeExternal(messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
+    publishExternalDirect<T>(eventName: EventName, message: MessagePayload, topic?: Topic, options?: PublishDirectOptions): Promise<T>;
+    publishExternal(eventName: EventName, message: MessagePayload, options?: PublishExternalEventOptions): Promise<boolean>;
+    getStatus(): RabbitMQStatus;
+    private preparePublisherHeaders;
+    private findTopicNameByEventName;
+    private setListener;
+    private setPublisher;
+    private getConnection;
+    private checkAndBindToExchange;
+    private bindQueueToExternalExchange;
+    private makeQueueName;
+    private makeExternalResQueueName;
+    private makeExternalReqQueueName;
+    private prepareExternalTopicName;
+    private prepareExternalReqRoutingKey;
+    private prepareExternalResRoutingKey;
+    private prepareExternalQueuePrefix;
+}

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

@@ -0,0 +1,16 @@
+import { Logger, OnInit } from '@diia-inhouse/types';
+import { EventBusListener, EventBusQueue, MessageHandler, MessagePayload, PublishInternalEventOptions, SubscribeOptions } from '../interfaces';
+import { QueueName } from '../interfaces/queueConfig';
+import { RabbitMQProvider } from '../providers/rabbitmq';
+import { EventMessageHandler } from './eventMessageHandler';
+export declare class EventBus implements EventBusQueue, OnInit {
+    private readonly queueProvider;
+    private readonly eventListenerList;
+    private readonly eventMessageHandler;
+    private readonly logger;
+    private readonly queueName;
+    constructor(queueProvider: RabbitMQProvider, eventListenerList: EventBusListener[], eventMessageHandler: EventMessageHandler, logger: Logger, queueName: QueueName | undefined);
+    onInit(): Promise<void>;
+    subscribe(subscriptionName: QueueName, messageHandler: MessageHandler, options?: SubscribeOptions): Promise<boolean>;
+    publish(eventName: QueueName, message: MessagePayload, options?: PublishInternalEventOptions): Promise<boolean>;
+}

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

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

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

@@ -0,0 +1,9 @@
+import { AppValidator, ValidationSchema } from '@diia-inhouse/validators';
+import { QueueMessageData } from '../interfaces';
+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

@@ -0,0 +1,24 @@
+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 { EventMessageValidator } from './eventMessageValidator';
+import { ExternalCommunicatorChannel } from './externalCommunicatorChannel';
+export declare class ExternalCommunicator implements OnRegistrationsFinished {
+    private readonly externalChannel;
+    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>;
+}

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

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

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

@@ -0,0 +1,18 @@
+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 { RabbitMQProvider } from '../providers/rabbitmq';
+import { EventMessageHandler } from './eventMessageHandler';
+export declare class ExternalEventBus implements ExternalEventBusQueue, OnInit {
+    private readonly queueProvider;
+    private readonly externalEventListenerList;
+    private readonly eventMessageHandler;
+    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>;
+}

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

@@ -0,0 +1,9 @@
+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';

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { HealthCheckResult, Logger, OnHealthCheck } from '@diia-inhouse/types';
+import { 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 connectionConfig;
+    private readonly asyncLocalStorage;
+    private readonly logger;
+    private internalQueue;
+    private externalQueue;
+    constructor(serviceName: string, connectionConfig: QueueConnectionConfig, asyncLocalStorage: AsyncLocalStorage<QueueContext>, logger: Logger);
+    onHealthCheck(): Promise<HealthCheckResult<QueueStatus>>;
+    getInternalQueue(): RabbitMQProvider;
+    getExternalQueue(): RabbitMQProvider;
+}

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

@@ -0,0 +1,17 @@
+import { Logger, OnInit } from '@diia-inhouse/types';
+import { EventBusListener, MessageHandler, ScheduledTasksQueue, SubscribeOptions } from '../interfaces';
+import { EventName, QueueName } from '../interfaces/queueConfig';
+import { RabbitMQProvider } from '../providers/rabbitmq';
+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>;
+}

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

@@ -0,0 +1,18 @@
+import { Logger, OnInit } from '@diia-inhouse/types';
+import { MessageHandler, MessagePayload, SubscribeOptions, TaskListener, TaskQueue } from '../interfaces';
+import { RabbitMQProvider } from '../providers/rabbitmq';
+import { EventMessageHandler } from './eventMessageHandler';
+export declare class Task implements TaskQueue, OnInit {
+    private readonly queueProvider;
+    private readonly taskList;
+    private readonly eventMessageHandler;
+    private readonly logger;
+    constructor(queueProvider: RabbitMQProvider, taskList: TaskListener[], eventMessageHandler: EventMessageHandler, logger: Logger);
+    private readonly tasksMap;
+    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;
+    private capitalizeFirstLetter;
+}

package/dist/types/utils.d.ts

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

package/dist/utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectEventBusListeners = void 0;
+function collectEventBusListeners(eventBusListeners) {
+    const eventListeners = {};
+    for (const listener of eventBusListeners) {
+        eventListeners[listener.event] = listener;
+    }
+    return eventListeners;
+}
+exports.collectEventBusListeners = collectEventBusListeners;
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +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"}

package/package.json

@@ -0,0 +1,105 @@
+{
+    "name": "@diia-inhouse/diia-queue",
+    "version": "7.3.0",
+    "description": "Package provide queue functionality",
+    "main": "dist/index.js",
+    "types": "dist/types/index.d.ts",
+    "repository": "https://github.com/diia-open-source/be-diia-queue.git",
+    "author": "Diia",
+    "license": "SEE LICENSE IN LICENSE.md",
+    "engines": {
+        "node": ">=18"
+    },
+    "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 .",
+        "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",
+        "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"
+    },
+    "peerDependencies": {
+        "@diia-inhouse/diia-metrics": ">=3.6.0",
+        "@diia-inhouse/errors": ">=1.4.0",
+        "@diia-inhouse/redis": ">=2.1.1",
+        "@diia-inhouse/types": ">=5.0.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"
+    },
+    "release": {
+        "extends": "@diia-inhouse/configs/dist/semantic-release/package"
+    },
+    "commitlint": {
+        "extends": "@diia-inhouse/configs/dist/commitlint"
+    },
+    "eslintConfig": {
+        "extends": "@diia-inhouse/eslint-config",
+        "rules": {
+            "@typescript-eslint/no-unnecessary-condition": [
+                "off"
+            ]
+        },
+        "overrides": [
+            {
+                "files": [
+                    "*.ts"
+                ],
+                "parserOptions": {
+                    "project": [
+                        "./tsconfig.json",
+                        "./tests/tsconfig.json"
+                    ]
+                }
+            }
+        ]
+    },
+    "jest": {
+        "preset": "@diia-inhouse/configs/dist/jest"
+    },
+    "prettier": "@diia-inhouse/eslint-config/prettier",
+    "madge": {
+        "tsConfig": "./tsconfig.json"
+    }
+}