@autofleet/rabbit 4.0.2 → 4.1.0

package/src/lib/consts.ts

@@ -1,4 +1,7 @@
-export const DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 12;
+import type { BackoffOptions } from 'exponential-backoff';
+import type { ConsumeOptions } from './types';
+
+export const DEFAULT_DEAD_TTL_TWO_DAYS = 60_000 * 60 * 12;
 export const DEFAULT_LOCK_TIMEOUT = 1000 * 5;
 export const RETRY_HEADER = 'x-retry-count';
 export const TRACING_HEADER = 'x-trace-id';
@@ -14,15 +17,16 @@ export const DEFAULT_OPTIONS = {
   useConsumeWithLock: DEFAULT_USE_CONSUME_WITH_LOCK,
   auditContext: null,
   enableRabbitTrace: false,
-};
+} satisfies ConsumeOptions;
+
 export const ASSERT_VHOST_EXPONENTIAL_BACKOFF_DEV_ENV_CONFIG = {
   startingDelay: 500,
   timeMultiple: 4,
   numOfAttempts: 5,
-};
+} satisfies BackoffOptions;
 
 export const ASSERT_VHOST_EXPONENTIAL_BACKOFF_PROD_CONFIG = {
   startingDelay: 1,
   timeMultiple: 1,
   numOfAttempts: 5,
-};
+} satisfies BackoffOptions;

package/src/lib/redis.ts

@@ -1,9 +1,4 @@
-import bluebird from 'bluebird';
-
-const redis = require('redis');
-
-bluebird.promisifyAll(redis.RedisClient.prototype);
-bluebird.promisifyAll(redis.Multi.prototype);
+import { createClient } from 'redis';
 
 export type RedisConfig = {
   host: string;
@@ -11,6 +6,6 @@ export type RedisConfig = {
   prefix?: string;
 }
 
-const getRedisInstance = (config: RedisConfig): any => redis.createClient(config);
+const getRedisInstance = (config: RedisConfig): ReturnType<typeof createClient> => createClient({ socket: config });
 
 export default getRedisInstance;

package/src/lib/types.ts

@@ -1,26 +1,25 @@
-import { AmqpConnectionManager } from 'amqp-connection-manager';
-import { ConsumeMessage, Options, Replies } from 'amqplib';
+import type { AmqpConnectionManager } from 'amqp-connection-manager';
+import type { ConsumeMessage, Options, Replies } from 'amqplib';
 
 export interface ExchangesCache {
-  [key: string]: any
+  [key: string]: Replies.AssertExchange | undefined;
 }
 
 export interface QueuesCache {
-  [key: string]: any
+  [key: string]: Replies.AssertQueue | undefined;
 }
 
 export interface QueueSetupPromisesDictionary {
-  [key: string]: Promise<Replies.AssertQueue> | undefined
+  [key: string]: Promise<Replies.AssertQueue> | undefined;
 }
 
 export interface AssertExchangePromisesDictionary {
-  [key: string]: Promise<Replies.AssertExchange> | undefined
+  [key: string]: Promise<Replies.AssertExchange> | undefined;
 }
 
 export type CustomMessageHeaders = {
   redisTimestampValidationKey?: string;
 }
-export type RedisLockType = (args0?: string, arg1?: number) => Promise<any>
 export type ConsumeMessageOrNull = ConsumeMessage | null;
 
 export interface ConsumeOptions {
@@ -36,7 +35,13 @@ export interface ConsumeOptions {
   isQuorumQueue?: boolean;
 }
 
-export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>
+export interface NackOptions {
+  skipRetry?: boolean;
+}
+
+export type Message = Omit<ConsumeMessage, 'content'> & { content: any; };
+
+export type CallbackFunction = (msg: Message, ack: () => Promise<void>, nack: (ignored: ConsumeMessageOrNull, nackOptions?: NackOptions) => Promise<void>) => Promise<void>;
 
 export type newChannelOpts = {
   name?: string;

package/src/lib/utils.ts

@@ -1,5 +1,6 @@
-import { ChannelWrapper } from 'amqp-connection-manager';
-import { ConfirmChannel, Replies } from 'amqplib';
+import type { ConfirmChannel, Replies } from 'amqplib';
+import type { ChannelWrapper } from 'amqp-connection-manager';
+import type { BackoffOptions } from 'exponential-backoff';
 import { ASSERT_VHOST_EXPONENTIAL_BACKOFF_PROD_CONFIG, ASSERT_VHOST_EXPONENTIAL_BACKOFF_DEV_ENV_CONFIG } from './consts';
 
 const { PROJECT_ID } = process.env;
@@ -9,21 +10,33 @@ export const assertExchangeFanout = async (
   exchangeName: string,
 ): Promise<Replies.AssertExchange> => c.assertExchange(exchangeName, 'fanout');
 
-export const wrapSetImmediate = (callback: () => any) => new Promise<any>((resolve, reject) => {
-  setImmediate(async () => {
-    try {
-      const value = await callback();
-      resolve(value);
-    } catch (error) {
-      reject(error);
-    }
+export const rand = (): number => Math.floor(Math.random() * 100_000);
+
+interface PromiseWithResolvers<T> {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: any) => void;
+}
+interface PromiseCls extends PromiseConstructor {
+  withResolvers<T>(): PromiseWithResolvers<T>;
+}
+/** This is polyfill for `Promise.withResolvers` which exists only on Node v22 and onwards */
+export const createDeferredPromise = <T = void>(): PromiseWithResolvers<T> => {
+  if ((Promise as PromiseCls).withResolvers) {
+    return (Promise as PromiseCls).withResolvers<T>();
+  }
+  let resolve!: PromiseWithResolvers<T>['resolve'];
+  let reject!: PromiseWithResolvers<T>['reject'];
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
   });
-});
-export const rand = () => Math.floor(Math.random() * 100000);
+  return { promise, resolve, reject };
+};
 
-const isDevEnv = () => ['af-experiment-manager', 'dev1-experiment-manager'].includes(PROJECT_ID || '');
+const isDevEnv = (): boolean => ['af-experiment-manager', 'dev1-experiment-manager'].includes(PROJECT_ID || '');
 
-export const getAssertVhostExponentialBackoffConfig = () => (
+export const getAssertVhostExponentialBackoffConfig = (): BackoffOptions => (
   isDevEnv()
     ? ASSERT_VHOST_EXPONENTIAL_BACKOFF_DEV_ENV_CONFIG
     : ASSERT_VHOST_EXPONENTIAL_BACKOFF_PROD_CONFIG);

package/src/redis-lock.d.ts

@@ -1,4 +1,6 @@
 declare module 'redis-lock' {
-    const lock: any;
-    export = lock;
-  }
+  import type { createClient } from 'redis';
+
+  declare function redisLock(client: ReturnType<typeof createClient>, retryDelay?: number): (lockName: string, timeout?: number) => Promise<() => Promise<void>>;
+  export = redisLock;
+}