@autofleet/rabbit 4.1.1 → 5.0.0

package/README.md

@@ -0,0 +1,8 @@
+# V5 migration
+
+The breaking change in this version is the removal of `zehut` from dependencies and usage as a peer-dependency.
+The required version of zehut is now `^4.0.0`.
+
+This was moved to being a peer-dependency in order to ensure that the version of `zehut` used here is the same as used in the MS, and not risk the package using v4 while the service is using v3, which would cause `zehut` to have multiple traces, which will not all hold the correct data.
+
+Additionally, the minimum node version is now 18, due to the minimum version of node defined in `zehut`.

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/index-B6pk4Ot8.d.cts

@@ -0,0 +1,216 @@
+import { EventEmitter } from "node:events";
+import RedisLock from "redis-lock";
+import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from "amqp-connection-manager";
+import { PublishOptions } from "amqp-connection-manager/dist/types/ChannelWrapper";
+import { ConfirmChannel, ConsumeMessage, Options, Replies } from "amqplib";
+import { LoggerInstanceManager } from "@autofleet/logger";
+import { createClient } from "redis";
+
+//#region src/lib/redis.d.ts
+type RedisConfig = {
+  host: string;
+  port: number | undefined;
+  prefix?: string;
+};
+declare const getRedisInstance: (config: RedisConfig) => ReturnType<typeof createClient>;
+//#endregion
+//#region src/lib/types.d.ts
+interface ExchangesCache {
+  [key: string]: Replies.AssertExchange | undefined;
+}
+interface QueuesCache {
+  [key: string]: Replies.AssertQueue | undefined;
+}
+interface QueueSetupPromisesDictionary {
+  [key: string]: Promise<Replies.AssertQueue> | undefined;
+}
+interface AssertExchangePromisesDictionary {
+  [key: string]: Promise<Replies.AssertExchange> | undefined;
+}
+type CustomMessageHeaders = {
+  redisTimestampValidationKey?: string;
+};
+type ConsumeMessageOrNull = ConsumeMessage | null;
+interface ConsumeOptions {
+  retries?: number;
+  deadMessageTtl?: number;
+  messageTtl?: number;
+  limit?: number;
+  lockTimeout?: number;
+  useConsumeWithLock?: boolean;
+  auditContext?: any;
+  enableRabbitTrace?: boolean;
+  isQuorumQueue?: boolean;
+}
+interface NackOptions {
+  skipRetry?: boolean;
+}
+type Message = Omit<ConsumeMessage, "content"> & {
+  content: any;
+};
+type CallbackFunction = (msg: Message, ack: () => Promise<void>, nack: (ignored: ConsumeMessageOrNull, nackOptions?: NackOptions) => Promise<void>) => Promise<void>;
+type ConnectionData = {
+  amqpConnection: AmqpConnectionManager | null;
+  creatingConnection: boolean;
+  connectionCreatedEventName: string;
+  connectionFailedEventName: string;
+  blockReconnect: boolean;
+};
+//#endregion
+//#region src/lib/celery.d.ts
+interface TaskData {
+  [key: string]: any;
+}
+interface SendTaskOptions {
+  taskName: string;
+  queueName: string;
+}
+declare function sendCeleryTaskViaHttp(data: TaskData, {
+  taskName,
+  queueName
+}: SendTaskOptions): Promise<void>;
+//#endregion
+//#region src/index.d.ts
+interface IAfRabbitMq {
+  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>;
+}
+interface AfRabbitOptions {
+  disableReconnect?: boolean;
+  /**
+  * When you want your own grace-full shutdown, set this to true.
+  * @default false
+  */
+  dontGracefulShutdown?: boolean;
+  /**
+  * 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 {
+  #private;
+  readonly options: AfRabbitOptions;
+  private readonly redisConfig?;
+  static parseMsg(msg: ConsumeMessage): Message;
+  static validateName(type: string, name: string): void;
+  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;
+  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>;
+  /** A map of consumers' tags used for canceling consumption */
+  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;
+  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?: (() => 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<Replies.AssertQueue>;
+  private saveConsumer;
+  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<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,
+    connection
+  }: newChannelOpts): Promise<ChannelWrapper>;
+  getConnectionOld(connection: ConnectionData): Promise<AmqpConnectionManager>;
+  private saveConsumerOld;
+  assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+  setupQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+  assertChannelOld({
+    force,
+    connection
+  }: assertChannelOpts): Promise<ChannelWrapper>;
+  private deleteQueueOld;
+  assertExchangeOld(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
+  isConnectedOld(): Promise<boolean>;
+  private maskURL;
+}
+//#endregion
+export { AfRabbitOptions, IAfRabbitMq, RabbitMq, sendCeleryTaskViaHttp };
+//# sourceMappingURL=index-B6pk4Ot8.d.cts.map

package/dist/index-K1ijaudV.d.ts

@@ -0,0 +1,216 @@
+import { EventEmitter } from "node:events";
+import RedisLock from "redis-lock";
+import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from "amqp-connection-manager";
+import { LoggerInstanceManager } from "@autofleet/logger";
+import { createClient } from "redis";
+import { PublishOptions } from "amqp-connection-manager/dist/types/ChannelWrapper";
+import { ConfirmChannel, ConsumeMessage, Options, Replies } from "amqplib";
+
+//#region src/lib/redis.d.ts
+type RedisConfig = {
+  host: string;
+  port: number | undefined;
+  prefix?: string;
+};
+declare const getRedisInstance: (config: RedisConfig) => ReturnType<typeof createClient>;
+//#endregion
+//#region src/lib/types.d.ts
+interface ExchangesCache {
+  [key: string]: Replies.AssertExchange | undefined;
+}
+interface QueuesCache {
+  [key: string]: Replies.AssertQueue | undefined;
+}
+interface QueueSetupPromisesDictionary {
+  [key: string]: Promise<Replies.AssertQueue> | undefined;
+}
+interface AssertExchangePromisesDictionary {
+  [key: string]: Promise<Replies.AssertExchange> | undefined;
+}
+type CustomMessageHeaders = {
+  redisTimestampValidationKey?: string;
+};
+type ConsumeMessageOrNull = ConsumeMessage | null;
+interface ConsumeOptions {
+  retries?: number;
+  deadMessageTtl?: number;
+  messageTtl?: number;
+  limit?: number;
+  lockTimeout?: number;
+  useConsumeWithLock?: boolean;
+  auditContext?: any;
+  enableRabbitTrace?: boolean;
+  isQuorumQueue?: boolean;
+}
+interface NackOptions {
+  skipRetry?: boolean;
+}
+type Message = Omit<ConsumeMessage, "content"> & {
+  content: any;
+};
+type CallbackFunction = (msg: Message, ack: () => Promise<void>, nack: (ignored: ConsumeMessageOrNull, nackOptions?: NackOptions) => Promise<void>) => Promise<void>;
+type ConnectionData = {
+  amqpConnection: AmqpConnectionManager | null;
+  creatingConnection: boolean;
+  connectionCreatedEventName: string;
+  connectionFailedEventName: string;
+  blockReconnect: boolean;
+};
+//#endregion
+//#region src/lib/celery.d.ts
+interface TaskData {
+  [key: string]: any;
+}
+interface SendTaskOptions {
+  taskName: string;
+  queueName: string;
+}
+declare function sendCeleryTaskViaHttp(data: TaskData, {
+  taskName,
+  queueName
+}: SendTaskOptions): Promise<void>;
+//#endregion
+//#region src/index.d.ts
+interface IAfRabbitMq {
+  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>;
+}
+interface AfRabbitOptions {
+  disableReconnect?: boolean;
+  /**
+  * When you want your own grace-full shutdown, set this to true.
+  * @default false
+  */
+  dontGracefulShutdown?: boolean;
+  /**
+  * 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 {
+  #private;
+  readonly options: AfRabbitOptions;
+  private readonly redisConfig?;
+  static parseMsg(msg: ConsumeMessage): Message;
+  static validateName(type: string, name: string): void;
+  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;
+  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>;
+  /** A map of consumers' tags used for canceling consumption */
+  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;
+  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?: (() => 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<Replies.AssertQueue>;
+  private saveConsumer;
+  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<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,
+    connection
+  }: newChannelOpts): Promise<ChannelWrapper>;
+  getConnectionOld(connection: ConnectionData): Promise<AmqpConnectionManager>;
+  private saveConsumerOld;
+  assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+  setupQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+  assertChannelOld({
+    force,
+    connection
+  }: assertChannelOpts): Promise<ChannelWrapper>;
+  private deleteQueueOld;
+  assertExchangeOld(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
+  isConnectedOld(): Promise<boolean>;
+  private maskURL;
+}
+//#endregion
+export { AfRabbitOptions, IAfRabbitMq, RabbitMq, sendCeleryTaskViaHttp };
+//# sourceMappingURL=index-K1ijaudV.d.ts.map