@autofleet/rabbit 3.2.14 → 3.2.15

package/.nvmrc

@@ -1 +1 @@
-v16
+v20

package/dist/index.d.ts

@@ -3,7 +3,6 @@ import { EventEmitter } from 'events';
 import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from 'amqp-connection-manager';
 import { ConfirmChannel, ConsumeMessage, Options, Replies } from 'amqplib';
 import { RedisConfig } from './lib/redis';
-import { TRACING_HEADER, USER_TRACING_HEADER } from './lib/consts';
 import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
@@ -34,12 +33,12 @@ export interface AfRabbitOptions {
     dontRetryAssert?: boolean;
     rabbitHost?: string;
 }
-declare type newChannelOpts = {
+type newChannelOpts = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
     options?: CreateChannelOpts | undefined;
 };
-declare type assertChannelOpts = {
+type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
 };

package/dist/index.js

@@ -10,7 +10,7 @@ const moment_1 = __importDefault(require("moment"));
 const redis_lock_1 = __importDefault(require("redis-lock"));
 const amqp_connection_manager_1 = require("amqp-connection-manager");
 const zehut_1 = require("@autofleet/zehut");
-const uuid_1 = require("uuid");
+const node_crypto_1 = require("node:crypto");
 const logger_1 = __importDefault(require("./logger"));
 const rabbitError_1 = __importDefault(require("./lib/rabbitError"));
 const redis_1 = __importDefault(require("./lib/redis"));
@@ -18,10 +18,43 @@ const utils_1 = require("./lib/utils");
 const consts_1 = require("./lib/consts");
 const types_1 = require("./lib/types");
 // const debug = nodeDebug('af-rabbitmq')
-const debug = logger_1.default.info;
+const debug = logger_1.default.info.bind(logger_1.default);
 const PUBLISH_TIMEOUT = 1000 * 10;
 const HEARTBEAT = '60';
 class RabbitMq {
+    static parseMsg(msg) {
+        let { content } = msg;
+        content = content.toString();
+        try {
+            content = JSON.parse(content);
+        }
+        catch (e) { }
+        return {
+            ...msg,
+            content,
+        };
+    }
+    static validateName(type, name) {
+        if (!name || name === '') {
+            throw new rabbitError_1.default(`error while using ${type} with no name`);
+        }
+    }
+    static getPublishOptions(customHeaders = {}) {
+        const trace = (0, zehut_1.getCurrentPayload)();
+        const user = trace?.context?.get(consts_1.USER_OBJECT);
+        const traceId = trace?.context?.get(consts_1.TRACING_HEADER);
+        const outbreakTrace = zehut_1.outbreak.getCurrentContext();
+        return {
+            timestamp: (0, moment_1.default)().unix(),
+            timeout: PUBLISH_TIMEOUT,
+            headers: {
+                creationTimestamp: (0, moment_1.default)().valueOf(),
+                ...customHeaders,
+                [consts_1.USER_TRACING_HEADER]: user?.id,
+                [consts_1.TRACING_HEADER]: traceId || outbreakTrace?.context?.get(consts_1.TRACING_HEADER),
+            },
+        };
+    }
     constructor(options, redisConfig) {
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
         this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
@@ -90,9 +123,9 @@ class RabbitMq {
         this.queues = {};
         this.consumers = [];
         this.options = options;
-        this.redisClient = redisConfig && redis_1.default(redisConfig);
+        this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
         if (this.redisClient) {
-            this.redisLock = util_1.promisify(redis_lock_1.default(this.redisClient));
+            this.redisLock = (0, util_1.promisify)((0, redis_lock_1.default)(this.redisClient));
         }
         this.consumersTags = [];
         logger_1.default.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
@@ -105,39 +138,6 @@ class RabbitMq {
             });
         }
     }
-    static parseMsg(msg) {
-        let { content } = msg;
-        content = content.toString();
-        try {
-            content = JSON.parse(content);
-        }
-        catch (e) { }
-        return {
-            ...msg,
-            content,
-        };
-    }
-    static validateName(type, name) {
-        if (!name || name === '') {
-            throw new rabbitError_1.default(`error while using ${type} with no name`);
-        }
-    }
-    static getPublishOptions(customHeaders = {}) {
-        const trace = zehut_1.getCurrentPayload();
-        const user = trace?.context?.get(consts_1.USER_OBJECT);
-        const traceId = trace?.context?.get(consts_1.TRACING_HEADER);
-        const outbreakTrace = zehut_1.outbreak.getCurrentContext();
-        return {
-            timestamp: moment_1.default().unix(),
-            timeout: PUBLISH_TIMEOUT,
-            headers: {
-                creationTimestamp: moment_1.default().valueOf(),
-                ...customHeaders,
-                [consts_1.USER_TRACING_HEADER]: user?.id,
-                [consts_1.TRACING_HEADER]: traceId || outbreakTrace?.context?.get(consts_1.TRACING_HEADER),
-            },
-        };
-    }
     async getConnection() {
         return new Promise(async (resolve, reject) => {
             if (this.blockReconnect) {
@@ -174,7 +174,7 @@ class RabbitMq {
                 return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
             };
             const defaultUrls = findServers();
-            const connection = await amqp_connection_manager_1.connect(defaultUrls, {
+            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
             this.connection = connection;
@@ -215,41 +215,29 @@ class RabbitMq {
             });
         });
     }
-    async getNewChannel({ name = utils_1.rand().toString(), onClose = null, options = {} } = {}) {
-        return new Promise(async (resolve, reject) => {
-            let connection;
-            try {
-                connection = await this.getConnection();
-            }
-            catch (e) {
-                logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
-                reject(e);
-            }
-            const channel = connection?.createChannel({
-                ...options,
-            });
-            let isResolved = false;
-            if (channel) {
-                channel.on('error', (err) => {
-                    logger_1.default.error(`rabbit: channel error ${name} error`, { err });
-                    if (!isResolved) {
-                        isResolved = true;
-                        reject(err);
-                    }
-                });
-                channel.on('close', (...args) => {
-                    logger_1.default.error(`rabbit: channel ${name} closed`, { args });
-                    if (onClose) {
-                        onClose(args);
-                    }
-                });
-                channel.once('connect', () => {
-                    debug(`rabbit: channel ${name} CONNECTED`);
-                    isResolved = true;
-                    resolve(channel);
-                });
-            }
+    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
+        let connection;
+        try {
+            connection = await this.getConnection();
+        }
+        catch (e) {
+            logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
+            throw e;
+        }
+        const channel = connection.createChannel({ ...options });
+        (0, events_1.once)(channel, 'close').then((args) => {
+            logger_1.default.error(`rabbit: channel ${name} closed`);
+            onClose?.(args);
         });
+        try {
+            await (0, events_1.once)(channel, 'connect');
+            debug(`rabbit: channel ${name} CONNECTED`);
+            return channel;
+        }
+        catch (err) {
+            logger_1.default.error(`rabbit: channel error ${name} error`, { err });
+            throw err;
+        }
     }
     async assertChannel({ force = false } = {}) {
         return new Promise(async (resolve, reject) => {
@@ -274,7 +262,7 @@ class RabbitMq {
         if (this.exchanges[exchangeName]) {
             return this.exchanges[exchangeName];
         }
-        const exchange = await utils_1.assertExchangeFanout(channel, exchangeName);
+        const exchange = await (0, utils_1.assertExchangeFanout)(channel, exchangeName);
         this.exchanges[exchangeName] = exchange;
         return exchange;
     }
@@ -363,7 +351,7 @@ class RabbitMq {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('queue', queue);
         this.saveConsumer(queue, callback, options);
-        const uniqueId = uuid_1.v4();
+        const uniqueId = (0, node_crypto_1.randomUUID)();
         const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
         if (useConsumeWithLock) {
             if (!this.redisLock) {
@@ -383,7 +371,7 @@ class RabbitMq {
                 const userId = msg.properties.headers[consts_1.USER_TRACING_HEADER];
                 const parsedMessage = RabbitMq.parseMsg(msg);
                 const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
-                const trace = zehut_1.newTrace(zehut_1.traceTypes.RABBIT);
+                const trace = (0, zehut_1.newTrace)(zehut_1.traceTypes.RABBIT);
                 // setting also outbreak trace as part of legacy code
                 const outbreakTrace = zehut_1.outbreak.newTrace(zehut_1.traceTypes.RABBIT);
                 // enableRabbitTrace is a flag to protect from different flows that doesn't work with permission
@@ -391,8 +379,8 @@ class RabbitMq {
                 if (userId && enableRabbitTrace) {
                     try {
                         await Promise.all([
-                            zehut_1.createOrSetRabbitTrace(trace, userId),
-                            zehut_1.createOrSetRabbitTrace(outbreakTrace, userId),
+                            (0, zehut_1.createOrSetRabbitTrace)(trace, userId),
+                            (0, zehut_1.createOrSetRabbitTrace)(outbreakTrace, userId),
                         ]);
                     }
                     catch (e) {
@@ -454,7 +442,7 @@ class RabbitMq {
         await this.saveConsumer(queue, callback, options);
         const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
         return channel.addSetup(async (c) => {
-            const assertExchange = await utils_1.assertExchangeFanout(c, exchange);
+            const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
             this.exchanges[exchange] = assertExchange;
             await c.prefetch(limit, true);
@@ -465,7 +453,7 @@ class RabbitMq {
         });
     }
     async publish(exchange, content, customHeaders) {
-        return utils_1.wrapSetImmediate(async () => {
+        return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
             const channel = await this.assertChannel();
             await this.assertExchange(exchange);
@@ -490,7 +478,7 @@ class RabbitMq {
         if (isBlocking) {
             return callback();
         }
-        return utils_1.wrapSetImmediate(callback);
+        return (0, utils_1.wrapSetImmediate)(callback);
     }
     async isConnected() {
         const connection = await this.getConnection();

package/dist/lib/redis.d.ts

@@ -1,4 +1,4 @@
-export declare type RedisConfig = {
+export type RedisConfig = {
     host: string;
     port: number | undefined;
     prefix?: string;

package/dist/lib/types.d.ts

@@ -5,11 +5,11 @@ export interface ExchangesCache {
 export interface QueuesCache {
     [key: string]: any;
 }
-export declare type CustomMessageHeaders = {
+export type CustomMessageHeaders = {
     redisTimestampValidationKey?: string;
 };
-export declare type RedisLockType = (args0?: string, arg1?: number) => Promise<any>;
-export declare type ConsumeMessageOrNull = ConsumeMessage | null;
+export type RedisLockType = (args0?: string, arg1?: number) => Promise<any>;
+export type ConsumeMessageOrNull = ConsumeMessage | null;
 export interface ConsumeOptions {
     retries?: number;
     deadMessageTtl?: number;
@@ -20,16 +20,16 @@ export interface ConsumeOptions {
     auditContext?: any;
     enableRabbitTrace?: boolean;
 }
-export declare type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>;
-export declare type newChannelOpts = {
+export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>;
+export type newChannelOpts = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
 };
-export declare type assertChannelOpts = {
+export type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
 };
-export declare type AfConsumer = {
+export type AfConsumer = {
     queue: string;
     callback: CallbackFunction;
     options: ConsumeOptions | undefined;

package/dist/lib/utils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rand = exports.wrapSetImmediate = exports.assertExchangeFanout = void 0;
-exports.assertExchangeFanout = async (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
-exports.wrapSetImmediate = (callback) => new Promise((resolve, reject) => {
+const assertExchangeFanout = async (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
+exports.assertExchangeFanout = assertExchangeFanout;
+const wrapSetImmediate = (callback) => new Promise((resolve, reject) => {
     setImmediate(async () => {
         try {
             const value = await callback();
@@ -13,4 +14,6 @@ exports.wrapSetImmediate = (callback) => new Promise((resolve, reject) => {
         }
     });
 });
-exports.rand = () => Math.floor(Math.random() * 100000);
+exports.wrapSetImmediate = wrapSetImmediate;
+const rand = () => Math.floor(Math.random() * 100000);
+exports.rand = rand;

package/dist/logger.d.ts

@@ -1,2 +1,2 @@
-declare const logger: any;
+declare const logger: import("@autofleet/logger").LoggerInstanceManager;
 export default logger;

package/dist/logger.js

@@ -1,5 +1,8 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const Logger = require('@autofleet/logger');
-const logger = Logger();
+const logger_1 = __importDefault(require("@autofleet/logger"));
+const logger = (0, logger_1.default)();
 exports.default = logger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.14",
+  "version": "3.2.15",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -15,32 +15,31 @@
     "dev": "nodemon"
   },
   "dependencies": {
-    "@autofleet/logger": "^1.2.8",
     "@autofleet/zehut": "3.0.8",
-    "@types/amqplib": "0.8.2",
-    "@types/uuid": "^8.3.3",
     "amqp-connection-manager": "4.1.9",
     "amqplib": "0.10.3",
     "bluebird": "^3.7.2",
     "moment": "^2.29.1",
     "redis": "^3.1.2",
-    "redis-lock": "^0.1.4",
-    "uuid": "^8.3.2"
+    "redis-lock": "^0.1.4"
   },
   "peerDependencies": {
-    "@autofleet/outbreak": "^1.0.4"
+    "@autofleet/logger": "*"
   },
   "devDependencies": {
-    "@types/jest": "^26.0.23",
+    "@autofleet/logger": "4.0.6",
+    "@types/amqplib": "0.8.2",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.14.11",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
     "eslint": "^7.13.0",
     "eslint-config-airbnb-typescript": "^12.0.0",
     "eslint-plugin-import": "^2.22.1",
-    "jest": "^27.0.5",
+    "jest": "^29.7.0",
     "node-tcp-proxy": "^0.0.28",
-    "ts-jest": "^27.0.3",
+    "ts-jest": "^29.2.3",
     "ts-node": "^8.6.2",
-    "typescript": "^3.8.3"
+    "typescript": "^4.9.5"
   },
   "author": "",
   "license": "ISC"

package/src/index.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars */
 
-import { EventEmitter } from 'events';
+import { EventEmitter, once } from 'events';
 import { promisify } from 'util';
 import moment from 'moment';
 import RedisLock from 'redis-lock';
@@ -13,7 +13,7 @@ import {
 import {
   getCurrentPayload, newTrace, traceTypes, createOrSetRabbitTrace, outbreak,
 } from '@autofleet/zehut';
-import { v4 } from 'uuid';
+import { randomUUID } from 'node:crypto';
 import logger from './logger';
 import RabbitError from './lib/rabbitError';
 import getRedisInstance, { RedisConfig } from './lib/redis';
@@ -39,7 +39,7 @@ import {
 } from './lib/types';
 
 // const debug = nodeDebug('af-rabbitmq')
-const debug = logger.info;
+const debug = logger.info.bind(logger);
 
 const PUBLISH_TIMEOUT = 1000 * 10;
 
@@ -112,7 +112,7 @@ class RabbitMq implements IAfRabbitMq {
     };
   }
 
-  static validateName(type: string, name: string) {
+  static validateName(type: string, name: string): void {
     if (!name || name === '') {
       throw new RabbitError(`error while using ${type} with no name`);
     }
@@ -349,40 +349,26 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async getNewChannel({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
-    return new Promise<ChannelWrapper>(async (resolve, reject) => {
-      let connection!: AmqpConnectionManager;
-      try {
-        connection = await this.getConnection();
-      } catch (e) {
-        logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
-        reject(e);
-      }
-      const channel = connection?.createChannel({
-        ...options,
-      });
-
-      let isResolved = false;
-      if (channel) {
-        channel.on('error', (err) => {
-          logger.error(`rabbit: channel error ${name} error`, { err });
-          if (!isResolved) {
-            isResolved = true;
-            reject(err);
-          }
-        });
-        channel.on('close', (...args) => {
-          logger.error(`rabbit: channel ${name} closed`, { args });
-          if (onClose) {
-            onClose(args);
-          }
-        });
-        channel.once('connect', () => {
-          debug(`rabbit: channel ${name} CONNECTED`);
-          isResolved = true;
-          resolve(channel);
-        });
-      }
+    let connection!: AmqpConnectionManager;
+    try {
+      connection = await this.getConnection();
+    } catch (e) {
+      logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
+      throw e;
+    }
+    const channel = connection.createChannel({ ...options });
+    once(channel, 'close').then((args) => {
+      logger.error(`rabbit: channel ${name} closed`);
+      onClose?.(args);
     });
+    try {
+      await once(channel, 'connect');
+      debug(`rabbit: channel ${name} CONNECTED`);
+      return channel;
+    } catch (err) {
+      logger.error(`rabbit: channel error ${name} error`, { err });
+      throw err;
+    }
   }
 
   async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
@@ -511,7 +497,7 @@ class RabbitMq implements IAfRabbitMq {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('queue', queue);
     this.saveConsumer(queue, callback, options);
-    const uniqueId = v4();
+    const uniqueId = randomUUID();
     const {
       limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace,
     } = optionsWithDefaults;

package/src/logger.ts

@@ -1,4 +1,4 @@
-const Logger = require('@autofleet/logger');
+import Logger from '@autofleet/logger';
 
 const logger = Logger();
 

package/tsconfig.json

@@ -7,7 +7,10 @@
     "strict": true,
     "esModuleInterop": true,
     "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
+    "emitDecoratorMetadata": true,
+    "skipLibCheck": true,
+    "types": ["@types/jest"]
   },
-  "exclude": ["node_modules", "**/*.test.ts"]
+  "exclude": ["node_modules"],
+  "include": ["src/**/*.ts"]
 }