@autofleet/rabbit 4.1.0-beta.0 → 4.1.0

package/dist/index.d.ts

@@ -1,23 +1,23 @@
 /// <reference types="node" />
-import { EventEmitter } from 'events';
-import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from 'amqp-connection-manager';
+import { EventEmitter } from 'node:events';
+import RedisLock from 'redis-lock';
+import { type AmqpConnectionManager, type ChannelWrapper, type CreateChannelOpts } from 'amqp-connection-manager';
+import type { PublishOptions } from 'amqp-connection-manager/dist/types/ChannelWrapper';
 import { ConfirmChannel, ConsumeMessage, Options, Replies } from 'amqplib';
-import { RedisConfig } from './lib/redis';
-import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, AssertExchangePromisesDictionary } from './lib/types';
+import type { LoggerInstanceManager } from '@autofleet/logger';
+import getRedisInstance, { RedisConfig } from './lib/redis';
+import { type AssertExchangePromisesDictionary, type CallbackFunction, type ConnectionData, type ConsumeMessageOrNull, type ConsumeOptions, type CustomMessageHeaders, type ExchangesCache, type Message, type NackOptions, type QueuesCache, type QueueSetupPromisesDictionary } from './lib/types';
 export interface IAfRabbitMq {
-    ack: any;
-    nack: any;
-    assertChannel: any;
-    assertExchange: any;
-    assertQueue: any;
-    consume: any;
-    consumeFromExchange: any;
-    publish: any;
-    sendToQueue: any;
-    redisClient?: any;
-}
-interface NackOptions {
-    skipRetry?: boolean;
+    ack(channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: (() => Promise<void>) | null): (userMsg: ConsumeMessage) => Promise<void>;
+    nack(channel: ConfirmChannel, queue: string, options: ConsumeOptions, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock?: () => Promise<void>): (userMsg: ConsumeMessageOrNull, nackOptions?: NackOptions) => Promise<void>;
+    assertChannel(options?: assertChannelOpts): Promise<ChannelWrapper>;
+    assertExchange(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
+    assertQueue(queueName: string, options?: Options.AssertQueue | null): Promise<Replies.AssertQueue>;
+    consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
+    consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
+    publish(exchange: string, content: any, customHeaders?: PublishOptions['headers']): Promise<void>;
+    sendToQueue(queue: string, content: any, options?: Options.AssertQueue | null, customHeaders?: PublishOptions['headers']): Promise<boolean | undefined>;
+    redisClient?: ReturnType<typeof getRedisInstance>;
 }
 export interface AfRabbitOptions {
     disableReconnect?: boolean;
@@ -27,102 +27,107 @@ export interface AfRabbitOptions {
      */
     dontGracefulShutdown?: boolean;
     /**
-     * dont retry on creation error
+     * don't retry on creation error
      * @default false
      */
     dontRetryAssert?: boolean;
     rabbitHost?: string;
     vhost?: string;
+    logger?: LoggerInstanceManager;
 }
 type newChannelOpts = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
     options?: CreateChannelOpts | undefined;
+    connection: ConnectionData;
 };
 type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
+    connection: ConnectionData;
 };
 declare class RabbitMq implements IAfRabbitMq {
-    static parseMsg(msg: any): any;
+    #private;
+    readonly options: AfRabbitOptions;
+    private readonly redisConfig?;
+    static parseMsg(msg: ConsumeMessage): Message;
     static validateName(type: string, name: string): void;
-    static getPublishOptions(customHeaders?: CustomMessageHeaders): {
-        timestamp: number;
-        timeout: number;
-        headers: {
-            "x-af-user-id": any;
-            "x-trace-id": any;
-            redisTimestampValidationKey?: string | undefined;
-            creationTimestamp: number;
-        };
-    };
-    DISCONNECT_MSG: string;
-    RECONNECT_MSG: string;
-    channel: ChannelWrapper | null;
+    static getPublishOptions(customHeaders?: CustomMessageHeaders): PublishOptions;
+    readonly DISCONNECT_MSG = "rabbit: connection disconnect";
+    readonly RECONNECT_MSG = "rabbit: connection disconnect - reconnecting";
+    publishChannel: ChannelWrapper | null;
     publishChannelSetupPromise: Promise<ChannelWrapper> | null;
-    blockReconnect: boolean | null | undefined;
-    connection: AmqpConnectionManager | null | undefined;
-    em: EventEmitter;
-    creatingConnection: boolean;
-    exchanges: ExchangesCache;
-    queues: QueuesCache;
-    queueSetupPromises: QueueSetupPromisesDictionary;
-    assertExchangePromises: AssertExchangePromisesDictionary;
-    options: AfRabbitOptions | undefined;
-    redisClient: any;
-    redisLock?: RedisLockType;
+    readonly publishConnection: ConnectionData;
+    readonly consumeConnection: ConnectionData;
+    readonly em: EventEmitter;
+    readonly exchanges: ExchangesCache;
+    readonly queues: QueuesCache;
+    readonly queueSetupPromises: QueueSetupPromisesDictionary;
+    readonly assertExchangePromises: AssertExchangePromisesDictionary;
+    readonly redisClient?: ReturnType<typeof getRedisInstance>;
+    readonly redisLock?: ReturnType<typeof RedisLock>;
     /** Array of consumers tags used for canceling consumption */
-    consumersTags: Array<[ConfirmChannel, string]>;
-    private consumers;
-    private isVHostExist;
-    oldChannel: ChannelWrapper | null;
+    readonly consumersTags: Map<string, {
+        channel: ConfirmChannel;
+        consumerTag: string;
+    }>;
+    private readonly consumersToRegister;
+    private doesVHostExist;
+    private readonly vhost;
+    private gracefulShutdownStarted;
+    oldPublishChannel: ChannelWrapper | null;
     oldPublishChannelSetupPromise: Promise<ChannelWrapper> | null;
-    oldBlockReconnect: boolean | null | undefined;
-    oldConnection: AmqpConnectionManager | null | undefined;
-    oldEm: EventEmitter;
-    oldCreatingConnection: boolean;
-    oldExchanges: ExchangesCache;
-    oldQueues: QueuesCache;
-    oldQueueSetupPromises: QueueSetupPromisesDictionary;
-    oldAssertExchangePromises: AssertExchangePromisesDictionary;
-    oldConsumersTags: Array<[ConfirmChannel, string]>;
-    private oldConsumers;
-    constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
+    readonly oldPublishConnection: ConnectionData;
+    readonly oldConsumeConnection: ConnectionData;
+    readonly oldEm: EventEmitter;
+    readonly oldExchanges: ExchangesCache;
+    readonly oldQueues: QueuesCache;
+    readonly oldQueueSetupPromises: QueueSetupPromisesDictionary;
+    readonly oldAssertExchangePromises: AssertExchangePromisesDictionary;
+    readonly oldConsumersTags: Map<string, {
+        channel: ConfirmChannel;
+        consumerTag: string;
+    }>;
+    private readonly oldConsumersToRegister;
+    constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig | undefined);
+    private getRedisKey;
     private assertVHost;
     private shouldConsumeMessageByTimestamp;
-    ack: (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
-    nack: (channel: ConfirmChannel, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: NackOptions) => Promise<any>;
-    getConnection(): Promise<AmqpConnectionManager>;
-    getNewChannel({ name, onClose, options }?: newChannelOpts): Promise<ChannelWrapper>;
-    assertChannel({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
-    assertExchange(exchangeName: string, options?: any): Promise<any>;
+    ack: (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: (() => Promise<void>) | null) => (userMsg: ConsumeMessage) => Promise<void>;
+    nack: (channel: ConfirmChannel, queue: string, options: ConsumeOptions, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock?: (() => Promise<void>) | null) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: NackOptions) => Promise<void>;
+    getConnection(connection: ConnectionData): Promise<AmqpConnectionManager>;
+    getNewChannel({ name, onClose, options, connection, }: newChannelOpts): Promise<ChannelWrapper>;
+    assertChannel({ force, connection }: assertChannelOpts): Promise<ChannelWrapper>;
+    assertExchange(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
     getQueueLength(queue: string): Promise<Replies.AssertQueue>;
     private deleteQueue;
     bindQueue(queue: string, exchange: string): Promise<void>;
     setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
     static shouldUseQuorum(queueName: string): boolean;
-    assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any>;
+    assertQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
     private saveConsumer;
-    consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
-    consumeNew(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
-    consumeOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
+    consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
+    consumeNew(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
+    consumeOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
     private lockRedisIfNeeded;
     private unlockRedisIfNeeded;
     private consumeFromRabbit;
-    consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
-    publish(exchange: string, content: any, customHeaders?: any, isQuorumQueue?: boolean): Promise<boolean>;
-    sendToQueue(queue: string, content: any, options?: any, customHeaders?: any, isQuorumQueue?: boolean): Promise<boolean | undefined>;
+    consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
+    publish(exchange: string, content: any, customHeaders?: PublishOptions['headers'], isQuorumQueue?: boolean): Promise<void>;
+    sendToQueue(queue: string, content: any, options?: Options.AssertQueue, customHeaders?: PublishOptions['headers'], isQuorumQueue?: boolean): Promise<boolean | undefined>;
     isConnected(): Promise<boolean>;
     gracefulShutdown(signal: string): Promise<void>;
     private consumeFromRabbitOld;
-    getNewChannelOld({ name, onClose, options }?: newChannelOpts): Promise<ChannelWrapper>;
-    getConnectionOld(): Promise<AmqpConnectionManager>;
+    getNewChannelOld({ name, onClose, options, connection, }: newChannelOpts): Promise<ChannelWrapper>;
+    getConnectionOld(connection: ConnectionData): Promise<AmqpConnectionManager>;
     private saveConsumerOld;
-    assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<any>;
+    assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
     setupQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
-    assertChannelOld({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
+    assertChannelOld({ force, connection }: assertChannelOpts): Promise<ChannelWrapper>;
     private deleteQueueOld;
-    assertExchangeOld(exchangeName: string, options?: any): Promise<any>;
+    assertExchangeOld(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
+    isConnectedOld(): Promise<boolean>;
+    private maskURL;
 }
 export default RabbitMq;
 export { sendCeleryTaskViaHttp, } from './lib/celery';