@autofleet/rabbit 4.1.0-beta.0 → 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';
@@ -6,8 +9,6 @@ export const USER_TRACING_HEADER = 'x-af-user-id';
 export const AUTOMATION_ID_HEADER = 'x-af-automation-id';
 export const USER_OBJECT = 'userObject';
 export const DEFAULT_USE_CONSUME_WITH_LOCK = false;
-export const CONNECTION_CREATED_CONST = 'connectionCreated';
-export const CONNECTION_FAILED_CONST = 'connectionFailed';
 export const DEFAULT_OPTIONS = {
   limit: 1,
   retries: 1,
@@ -16,4 +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,25 +1,25 @@
-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 {
@@ -31,10 +31,17 @@ export interface ConsumeOptions {
   useConsumeWithLock?: boolean;
   auditContext?: any;
   enableRabbitTrace?: boolean;
+  // TODO: [QUORUM-PHASE-3] Redundant because all the queues are quorum queues
   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;
@@ -60,3 +67,11 @@ export const CONSUMER_DEFAULT_OPTIONS: Options.Consume = {
     [HA_PROMOTE_ON_SHUTDOWN]: 'always',
   },
 };
+
+export type ConnectionData = {
+  amqpConnection: AmqpConnectionManager | null;
+  creatingConnection: boolean;
+  connectionCreatedEventName: string;
+  connectionFailedEventName: string;
+  blockReconnect: boolean;
+};

package/src/lib/utils.ts

@@ -1,19 +1,42 @@
-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;
 
 export const assertExchangeFanout = async (
   c: ChannelWrapper | ConfirmChannel,
   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 = (): boolean => ['af-experiment-manager', 'dev1-experiment-manager'].includes(PROJECT_ID || '');
+
+export const getAssertVhostExponentialBackoffConfig = (): BackoffOptions => (
+  isDevEnv()
+    ? ASSERT_VHOST_EXPONENTIAL_BACKOFF_DEV_ENV_CONFIG
+    : ASSERT_VHOST_EXPONENTIAL_BACKOFF_PROD_CONFIG);

package/src/{mock.ts → mock/index.ts}

@@ -1,6 +1,6 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
+// eslint-disable-next-line import/no-unresolved
 import 'jest';
-import { IAfRabbitMq } from './index';
+import type { IAfRabbitMq } from '../index';
 
 class RabbitMq implements IAfRabbitMq {
   ack: any = jest.fn();

package/src/mock/vitest.ts

@@ -0,0 +1,24 @@
+import { vi } from 'vitest';
+import { IAfRabbitMq } from '../index';
+
+class RabbitMq implements IAfRabbitMq {
+  ack = vi.fn();
+
+  nack = vi.fn();
+
+  assertChannel = vi.fn();
+
+  assertExchange = vi.fn();
+
+  assertQueue = vi.fn();
+
+  consume = vi.fn();
+
+  consumeFromExchange = vi.fn();
+
+  publish = vi.fn();
+
+  sendToQueue = vi.fn();
+}
+
+export default RabbitMq;

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;
+}

package/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "src/example.ts", "**/*.test.ts"],
+}

package/tsconfig.json

@@ -9,8 +9,8 @@
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "skipLibCheck": true,
-    "types": ["@types/jest"]
+    "sourceMap": true,
   },
   "exclude": ["node_modules"],
-  "include": ["src/**/*.ts"]
+  "include": ["src/", "vitest.config.ts"],
 }

package/vitest.config.ts

@@ -0,0 +1,17 @@
+// eslint-disable-next-line import/no-unresolved
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: ['src/example.ts', 'src/mock/*.ts'],
+      reporter: 'text',
+      thresholds: {
+        // TO DO: Increase the coverage threshold back to 75 in phase 3
+        lines: 65,
+      },
+    },
+  },
+});