@autofleet/sequelize-utils 5.2.3 → 5.2.4

package/dist/common.d.ts

@@ -0,0 +1,2 @@
+import debug from 'debug';
+export declare const debugLog: debug.Debugger;

package/dist/common.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLog = void 0;
+const debug_1 = __importDefault(require("debug"));
+exports.debugLog = (0, debug_1.default)('sequelize-utils');

package/dist/http-based-transaction.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Sequelize, Transaction } from 'sequelize';
+export declare const httpBasedTransaction: <T>(sequelize: Sequelize, req: IncomingMessage, res: ServerResponse, cb: (transaction: Transaction) => Promise<T>) => Promise<T>;

package/dist/http-based-transaction.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpBasedTransaction = void 0;
+const common_1 = require("./common");
+const rollbackErrorText = 'rollback has been called on this transaction';
+const abortErrorText = 'Transaction cancelled due to request cancellation';
+const httpBasedTransaction = (sequelize, req, res, cb) => {
+    let aborted = false;
+    if (req.socket.destroyed) {
+        (0, common_1.debugLog)(abortErrorText);
+        throw new Error(abortErrorText);
+    }
+    return sequelize.transaction(async (transaction) => {
+        // https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/test/parallel/test-http-aborted.js#L9
+        // 2023-04-13: Node.js 16.0.0
+        // Added also the `res.writableFinished` check, because it seems that the socket is not destroyed when the request is aborted, but the response is not finished.
+        // https://github.com/Jimbly/http-proxy-node16/commit/ba0c414cd03799e357c5d867c11dea06a9c34ec8#diff-b2d1e3b7c5f3b424a0af7971c582c822fd25a5ea279040ef6dc93fc4b2cf619dR151
+        const rollback = async () => {
+            (0, common_1.debugLog)(abortErrorText);
+            if (aborted)
+                return;
+            aborted = true;
+            await transaction.rollback();
+        };
+        const resRollback = async () => {
+            const didNotFinishWrite = !res.writableFinished;
+            if (didNotFinishWrite) {
+                (0, common_1.debugLog)(abortErrorText);
+                if (aborted)
+                    return;
+                aborted = true;
+                await transaction.rollback();
+            }
+        };
+        req.socket.once('close', rollback);
+        res.once('close', resRollback);
+        const removeListeners = () => {
+            req.socket.removeListener('close', rollback);
+            res.removeListener('close', resRollback);
+        };
+        try {
+            const response = await cb(transaction);
+            removeListeners();
+            return response;
+        }
+        catch (e) {
+            removeListeners();
+            if (e.message.includes(rollbackErrorText)) {
+                throw new Error(abortErrorText);
+            }
+            throw e;
+        }
+    });
+};
+exports.httpBasedTransaction = httpBasedTransaction;

package/dist/index.d.ts

@@ -1,11 +1,14 @@
-import { Sequelize, Transaction, TransactionOptions } from 'sequelize';
-import type { IncomingMessage, ServerResponse } from 'http';
-import { ModelMapping } from './model-event-hooks';
+import type { Sequelize, Transaction } from 'sequelize';
+import addModelEventHooks from './model-event-hooks';
+import { transactionWithRetry as _transactionWithRetry } from './transaction-with-retry';
+import { httpBasedTransaction as _httpBasedTransaction } from './http-based-transaction';
 import runAfterTransactionCommits from './runAfterTransactionCommits';
+type ArgsWithoutSequelize<T> = T extends (arg1: Sequelize, ...args: infer U) => any ? U : never;
 declare const _default: (sequelize: Sequelize) => {
-    transactionWithRetry: <T>(funcToRun: (transaction: Transaction) => Promise<T>, retriesCount?: number, options?: TransactionOptions) => Promise<T>;
-    httpBasedTransaction: <T>(req: IncomingMessage, res: ServerResponse, cb: (transaction: Transaction) => Promise<T>) => Promise<T>;
-    registerModelEventHooks: (modelTableMapping: ModelMapping) => Promise<void>;
+    transactionWithRetry: <T>(...args: ArgsWithoutSequelize<typeof _transactionWithRetry<T>>) => Promise<T>;
+    httpBasedTransaction: <T>(...args: ArgsWithoutSequelize<typeof _httpBasedTransaction<T>>) => Promise<T>;
+    registerModelEventHooks: (...args: ArgsWithoutSequelize<typeof addModelEventHooks>) => void;
     runAfterTransactionCommits: typeof runAfterTransactionCommits;
+    useOrCreateTransaction: <T>(transaction: Transaction, cb: (t: Transaction) => Promise<T>) => Promise<T>;
 };
 export default _default;

package/dist/index.js

@@ -3,89 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable import/prefer-default-export */
-const sequelize_1 = require("sequelize");
-const debug_1 = __importDefault(require("debug"));
 const model_event_hooks_1 = __importDefault(require("./model-event-hooks"));
+const transaction_with_retry_1 = require("./transaction-with-retry");
+const http_based_transaction_1 = require("./http-based-transaction");
 const runAfterTransactionCommits_1 = __importDefault(require("./runAfterTransactionCommits"));
-const log = (0, debug_1.default)('sequelize-utils');
-const rollbackErrorText = 'rollback has been called on this transaction';
-const abortErrorText = 'Transaction cancelled due to request cancellation';
 exports.default = (sequelize) => {
-    const transactionWithRetry = async (funcToRun, retriesCount = 2, options = {}) => {
-        try {
-            const transValue = await sequelize.transaction(options, async (transaction) => {
-                const funcValue = await funcToRun(transaction);
-                return funcValue;
-            });
-            return transValue;
-        }
-        catch (e) {
-            if (e instanceof sequelize_1.DatabaseError || e?.constructor?.name === 'DatabaseError') {
-                if (retriesCount === 0) {
-                    log('error inside transactionWithRetry - will stop retry', e);
-                    throw e;
-                }
-                log(`error inside transactionWithRetry - will retry times ${retriesCount - 1}`, e);
-                return transactionWithRetry(funcToRun, retriesCount - 1);
-            }
-            throw e;
-        }
-    };
-    const httpBasedTransaction = (req, res, cb) => {
-        let aborted = false;
-        if (req.socket.destroyed) {
-            log(abortErrorText);
-            throw new Error(abortErrorText);
+    const transactionWithRetry = (funcToRun, retriesCount, options) => (0, transaction_with_retry_1.transactionWithRetry)(sequelize, funcToRun, retriesCount, options);
+    const httpBasedTransaction = (req, res, cb) => (0, http_based_transaction_1.httpBasedTransaction)(sequelize, req, res, cb);
+    const registerModelEventHooks = (modelTableMapping) => (0, model_event_hooks_1.default)(sequelize, modelTableMapping);
+    const useOrCreateTransaction = (transaction, cb) => {
+        if (transaction) {
+            return cb(transaction);
         }
-        return sequelize.transaction(async (transaction) => {
-            // https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/test/parallel/test-http-aborted.js#L9
-            // 2023-04-13: Node.js 16.0.0
-            // Added also the res.writableFinished check, becurse it seems that the socket is not destroyed
-            // when the request is aborted, but the response is not finished.
-            // https://github.com/Jimbly/http-proxy-node16/commit/ba0c414cd03799e357c5d867c11dea06a9c34ec8#diff-b2d1e3b7c5f3b424a0af7971c582c822fd25a5ea279040ef6dc93fc4b2cf619dR151
-            const rollback = async () => {
-                log(abortErrorText);
-                if (aborted)
-                    return;
-                aborted = true;
-                await transaction.rollback();
-            };
-            const resRollback = async () => {
-                const didNotFinishWrite = !res.writableFinished;
-                if (didNotFinishWrite) {
-                    log(abortErrorText);
-                    if (aborted)
-                        return;
-                    aborted = true;
-                    await transaction.rollback();
-                }
-            };
-            req.socket.once('close', rollback);
-            res.once('close', resRollback);
-            const removeListeners = () => {
-                req.socket.removeListener('close', rollback);
-                res.removeListener('close', resRollback);
-            };
-            try {
-                const response = await cb(transaction);
-                removeListeners();
-                return response;
-            }
-            catch (e) {
-                removeListeners();
-                if (e.message.includes(rollbackErrorText)) {
-                    throw new Error(abortErrorText);
-                }
-                throw e;
-            }
-        });
+        return transactionWithRetry(cb, 0);
     };
-    const registerModelEventHooks = (modelTableMapping) => (0, model_event_hooks_1.default)(sequelize, modelTableMapping);
     return {
         httpBasedTransaction,
         transactionWithRetry,
         registerModelEventHooks,
         runAfterTransactionCommits: runAfterTransactionCommits_1.default,
+        useOrCreateTransaction,
     };
 };

package/dist/model-event-hooks.d.ts

@@ -4,5 +4,5 @@ export interface ModelMapping {
         tableName: string;
     };
 }
-declare const addModelEventHooks: (sequelize: Sequelize, modelTableMapping: ModelMapping) => Promise<void>;
+declare const addModelEventHooks: (sequelize: Sequelize, modelTableMapping: ModelMapping) => void;
 export default addModelEventHooks;

package/dist/model-event-hooks.js

@@ -6,16 +6,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = __importDefault(require("./events"));
 const logger_1 = __importDefault(require("./logger"));
 const runAfterTransactionCommits_1 = __importDefault(require("./runAfterTransactionCommits"));
+const isDate = (input) => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
+// eslint-disable-next-line @typescript-eslint/ban-types
 const formatDatesInObject = (obj) => {
     const newObj = { ...obj };
-    Object.keys(newObj).forEach((key) => {
-        if (newObj[key] instanceof Date) {
-            newObj[key] = newObj[key].getTime() / 1000;
-        }
+    Object.entries(newObj).filter(([, value]) => isDate(value)).forEach(([key, value]) => {
+        newObj[key] = value.getTime() / 1000;
     });
     return newObj;
 };
-const addModelEventHooks = async (sequelize, modelTableMapping) => {
+const addModelEventHooks = (sequelize, modelTableMapping) => {
     const updateEventToDimTable = async (object, isDelete = false) => {
         try {
             const objectToSend = object.get();

package/dist/test-utils/db.d.ts

@@ -0,0 +1,2 @@
+import { Sequelize } from 'sequelize';
+export declare function createSequelizeInstance(): Sequelize;

package/dist/test-utils/db.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSequelizeInstance = createSequelizeInstance;
+const node_process_1 = require("node:process");
+const sequelize_1 = require("sequelize");
+function createSequelizeInstance() {
+    return new sequelize_1.Sequelize(node_process_1.env.DB_NAME || 'test_service_development', node_process_1.env.DB_USERNAME || '', node_process_1.env.DB_PASSWORD, {
+        host: node_process_1.env.DB_HOST || '127.0.0.1',
+        dialect: 'postgres',
+        operatorsAliases: sequelize_1.Op,
+        define: {
+            underscored: true,
+        },
+        pool: {
+            max: 10,
+            min: 1,
+        },
+    });
+}

package/dist/transaction-with-retry.d.ts

@@ -0,0 +1,2 @@
+import { type Sequelize, type Transaction, type TransactionOptions } from 'sequelize';
+export declare const transactionWithRetry: <T>(sequelize: Sequelize, funcToRun: (transaction: Transaction) => Promise<T>, retriesCount?: number, options?: TransactionOptions) => Promise<T>;

package/dist/transaction-with-retry.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionWithRetry = void 0;
+const sequelize_1 = require("sequelize");
+const common_1 = require("./common");
+const transactionWithRetry = async (sequelize, funcToRun, retriesCount = 2, options = {}) => {
+    if (typeof funcToRun !== 'function') {
+        throw new Error('funcToRun must be a function');
+    }
+    if (typeof retriesCount !== 'number') {
+        throw new Error('if defined, retriesCount must be a number');
+    }
+    if (retriesCount < 0) {
+        throw new Error('retriesCount must be a positive number');
+    }
+    try {
+        const transValue = await sequelize.transaction(options, async (transaction) => {
+            const funcValue = await funcToRun(transaction);
+            return funcValue;
+        });
+        return transValue;
+    }
+    catch (e) {
+        if ((e instanceof sequelize_1.DatabaseError || e?.constructor?.name === 'DatabaseError') && --retriesCount >= 0) {
+            (0, common_1.debugLog)(`error inside transactionWithRetry - will retry times ${retriesCount}`, e);
+            return (0, exports.transactionWithRetry)(sequelize, funcToRun, retriesCount, options);
+        }
+        if (retriesCount === -1) {
+            (0, common_1.debugLog)('error inside transactionWithRetry - will stop retry', e);
+        }
+        throw e;
+    }
+};
+exports.transactionWithRetry = transactionWithRetry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sequelize-utils",
-  "version": "5.2.3",
+  "version": "5.2.4",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -8,9 +8,9 @@
     "prepublish": "tsc -p tsconfig.build.json",
     "build": "tsc -p tsconfig.build.json",
     "lint": "eslint .",
-    "test": "jest --forceExit",
-    "test-local": "jest --forceExit",
-    "coverage": "jest --coverage --forceExit --runInBand"
+    "test": "jest",
+    "test-local": "jest",
+    "coverage": "jest --coverage --runInBand"
   },
   "author": "",
   "license": "ISC",

package/src/common.ts

@@ -0,0 +1,3 @@
+import debug from 'debug';
+
+export const debugLog = debug('sequelize-utils');

package/src/http-based-transaction.ts

@@ -0,0 +1,56 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Sequelize, Transaction } from 'sequelize';
+import { debugLog } from './common';
+
+const rollbackErrorText = 'rollback has been called on this transaction';
+const abortErrorText = 'Transaction cancelled due to request cancellation';
+
+export const httpBasedTransaction = <T>(sequelize: Sequelize, req: IncomingMessage, res: ServerResponse, cb: (transaction: Transaction) => Promise<T>): Promise<T> => {
+  let aborted = false;
+  if (req.socket.destroyed) {
+    debugLog(abortErrorText);
+    throw new Error(abortErrorText);
+  }
+  return sequelize.transaction(async (transaction: Transaction) => {
+    // https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/test/parallel/test-http-aborted.js#L9
+
+    // 2023-04-13: Node.js 16.0.0
+    // Added also the `res.writableFinished` check, because it seems that the socket is not destroyed when the request is aborted, but the response is not finished.
+    // https://github.com/Jimbly/http-proxy-node16/commit/ba0c414cd03799e357c5d867c11dea06a9c34ec8#diff-b2d1e3b7c5f3b424a0af7971c582c822fd25a5ea279040ef6dc93fc4b2cf619dR151
+
+    const rollback = async () => {
+      debugLog(abortErrorText);
+      if (aborted) return;
+      aborted = true;
+      await transaction.rollback();
+    };
+    const resRollback = async () => {
+      const didNotFinishWrite = !res.writableFinished;
+      if (didNotFinishWrite) {
+        debugLog(abortErrorText);
+        if (aborted) return;
+        aborted = true;
+        await transaction.rollback();
+      }
+    };
+    req.socket.once('close', rollback);
+    res.once('close', resRollback);
+
+    const removeListeners = () => {
+      req.socket.removeListener('close', rollback);
+      res.removeListener('close', resRollback);
+    };
+
+    try {
+      const response = await cb(transaction);
+      removeListeners();
+      return response;
+    } catch (e) {
+      removeListeners();
+      if (e.message.includes(rollbackErrorText)) {
+        throw new Error(abortErrorText);
+      }
+      throw e;
+    }
+  });
+};

package/src/index.ts

@@ -1,103 +1,39 @@
 /* eslint-disable import/prefer-default-export */
-import {
-  DatabaseError,
+import type {
   Sequelize,
   Transaction,
   TransactionOptions,
 } from 'sequelize';
-import debug from 'debug';
 import type { IncomingMessage, ServerResponse } from 'http';
 import addModelEventHooks, { ModelMapping } from './model-event-hooks';
+import { transactionWithRetry as _transactionWithRetry } from './transaction-with-retry';
+import { httpBasedTransaction as _httpBasedTransaction } from './http-based-transaction';
 import runAfterTransactionCommits from './runAfterTransactionCommits';
 
-const log = debug('sequelize-utils');
-
-const rollbackErrorText = 'rollback has been called on this transaction';
-const abortErrorText = 'Transaction cancelled due to request cancellation';
+type ArgsWithoutSequelize<T> = T extends (arg1: Sequelize, ...args: infer U) => any ? U : never;
 
 export default (sequelize: Sequelize): {
-  transactionWithRetry: <T>(funcToRun: (transaction: Transaction) => Promise<T>, retriesCount?: number, options?: TransactionOptions) => Promise<T>;
-  httpBasedTransaction: <T>(req: IncomingMessage, res: ServerResponse, cb: (transaction: Transaction) => Promise<T>) => Promise<T>;
-  registerModelEventHooks: (modelTableMapping: ModelMapping) => Promise<void>;
+  transactionWithRetry: <T>(...args: ArgsWithoutSequelize<typeof _transactionWithRetry<T>>) => Promise<T>;
+  httpBasedTransaction: <T>(...args: ArgsWithoutSequelize<typeof _httpBasedTransaction<T>>) => Promise<T>;
+  registerModelEventHooks: (...args: ArgsWithoutSequelize<typeof addModelEventHooks>) => void;
   runAfterTransactionCommits: typeof runAfterTransactionCommits;
+  useOrCreateTransaction: <T>(transaction: Transaction, cb: (t: Transaction) => Promise<T>) => Promise<T>;
 } => {
-  const transactionWithRetry = async <T>(funcToRun: (transaction: Transaction) => Promise<T>, retriesCount = 2, options: TransactionOptions = {}): Promise<T> => {
-    try {
-      const transValue = await sequelize.transaction(options, async (transaction) => {
-        const funcValue = await funcToRun(transaction);
-        return funcValue;
-      });
-      return transValue;
-    } catch (e) {
-      if (e instanceof DatabaseError || e?.constructor?.name === 'DatabaseError') {
-        if (retriesCount === 0) {
-          log('error inside transactionWithRetry - will stop retry', e);
-          throw e;
-        }
-        log(`error inside transactionWithRetry - will retry times ${retriesCount - 1}`, e);
-        return transactionWithRetry(funcToRun, retriesCount - 1);
-      }
-      throw e;
+  const transactionWithRetry = <T>(funcToRun: (transaction: Transaction) => Promise<T>, retriesCount?: number, options?: TransactionOptions): Promise<T> => _transactionWithRetry(sequelize, funcToRun, retriesCount, options);
+  const httpBasedTransaction = <T>(req: IncomingMessage, res: ServerResponse, cb: (transaction: Transaction) => Promise<T>): Promise<T> => _httpBasedTransaction(sequelize, req, res, cb);
+  const registerModelEventHooks = (modelTableMapping: ModelMapping) => addModelEventHooks(sequelize, modelTableMapping);
+  const useOrCreateTransaction = <T>(transaction: Transaction, cb: (t: Transaction) => Promise<T>) => {
+    if (transaction) {
+      return cb(transaction);
     }
+    return transactionWithRetry(cb, 0);
   };
 
-  const httpBasedTransaction = <T>(req: IncomingMessage, res: ServerResponse, cb: (transaction: Transaction) => Promise<T>): Promise<T> => {
-    let aborted = false;
-    if (req.socket.destroyed) {
-      log(abortErrorText);
-      throw new Error(abortErrorText);
-    }
-    return sequelize.transaction(async (transaction: Transaction) => {
-      // https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/test/parallel/test-http-aborted.js#L9
-
-      // 2023-04-13: Node.js 16.0.0
-      // Added also the res.writableFinished check, becurse it seems that the socket is not destroyed
-      // when the request is aborted, but the response is not finished.
-      // https://github.com/Jimbly/http-proxy-node16/commit/ba0c414cd03799e357c5d867c11dea06a9c34ec8#diff-b2d1e3b7c5f3b424a0af7971c582c822fd25a5ea279040ef6dc93fc4b2cf619dR151
-
-      const rollback = async () => {
-        log(abortErrorText);
-        if (aborted) return;
-        aborted = true;
-        await transaction.rollback();
-      };
-      const resRollback = async () => {
-        const didNotFinishWrite = !res.writableFinished;
-        if (didNotFinishWrite) {
-          log(abortErrorText);
-          if (aborted) return;
-          aborted = true;
-          await transaction.rollback();
-        }
-      };
-      req.socket.once('close', rollback);
-      res.once('close', resRollback);
-
-      const removeListeners = () => {
-        req.socket.removeListener('close', rollback);
-        res.removeListener('close', resRollback);
-      };
-
-      try {
-        const response = await cb(transaction);
-        removeListeners();
-        return response;
-      } catch (e) {
-        removeListeners();
-        if (e.message.includes(rollbackErrorText)) {
-          throw new Error(abortErrorText);
-        }
-        throw e;
-      }
-    });
-  };
-
-  const registerModelEventHooks = (modelTableMapping: ModelMapping) => addModelEventHooks(sequelize, modelTableMapping);
-
   return {
     httpBasedTransaction,
     transactionWithRetry,
     registerModelEventHooks,
     runAfterTransactionCommits,
+    useOrCreateTransaction,
   };
 };

package/src/model-event-hooks.ts

@@ -8,18 +8,17 @@ export interface ModelMapping {
     tableName: string
   };
 }
-
-const formatDatesInObject = (obj: any) => {
+const isDate = (input: unknown): input is Date => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
+// eslint-disable-next-line @typescript-eslint/ban-types
+const formatDatesInObject = (obj: object) => {
   const newObj = { ...obj };
-  Object.keys(newObj).forEach((key) => {
-    if (newObj[key] instanceof Date) {
-      newObj[key] = newObj[key].getTime() / 1000;
-    }
+  Object.entries(newObj).filter(([, value]) => isDate(value)).forEach(([key, value]) => {
+    newObj[key] = (value as Date).getTime() / 1000;
   });
   return newObj;
 };
 
-const addModelEventHooks = async (sequelize: Sequelize, modelTableMapping: ModelMapping): Promise<void> => {
+const addModelEventHooks = (sequelize: Sequelize, modelTableMapping: ModelMapping): void => {
   const updateEventToDimTable = async (object: Model, isDelete = false) => {
     try {
       const objectToSend = object.get();

package/src/test-utils/db.ts

@@ -0,0 +1,22 @@
+import { env } from 'node:process';
+import { Sequelize, Op } from 'sequelize';
+
+export function createSequelizeInstance(): Sequelize {
+  return new Sequelize(
+    env.DB_NAME || 'test_service_development',
+    env.DB_USERNAME || '',
+    env.DB_PASSWORD,
+    {
+      host: env.DB_HOST || '127.0.0.1',
+      dialect: 'postgres',
+      operatorsAliases: Op,
+      define: {
+        underscored: true,
+      },
+      pool: {
+        max: 10,
+        min: 1,
+      },
+    },
+  );
+}

package/src/transaction-with-retry.ts

@@ -0,0 +1,32 @@
+import {
+  DatabaseError, type Sequelize, type Transaction, type TransactionOptions,
+} from 'sequelize';
+import { debugLog } from './common';
+
+export const transactionWithRetry = async <T>(sequelize: Sequelize, funcToRun: (transaction: Transaction) => Promise<T>, retriesCount = 2, options: TransactionOptions = {}): Promise<T> => {
+  if (typeof funcToRun !== 'function') {
+    throw new Error('funcToRun must be a function');
+  }
+  if (typeof retriesCount !== 'number') {
+    throw new Error('if defined, retriesCount must be a number');
+  }
+  if (retriesCount < 0) {
+    throw new Error('retriesCount must be a positive number');
+  }
+  try {
+    const transValue = await sequelize.transaction(options, async (transaction) => {
+      const funcValue = await funcToRun(transaction);
+      return funcValue;
+    });
+    return transValue;
+  } catch (e) {
+    if ((e instanceof DatabaseError || e?.constructor?.name === 'DatabaseError') && --retriesCount >= 0) {
+      debugLog(`error inside transactionWithRetry - will retry times ${retriesCount}`, e);
+      return transactionWithRetry(sequelize, funcToRun, retriesCount, options);
+    }
+    if (retriesCount === -1) {
+      debugLog('error inside transactionWithRetry - will stop retry', e);
+    }
+    throw e;
+  }
+};

package/tsconfig.build.json

@@ -3,6 +3,7 @@
   "exclude": [
     "node_modules",
     "dist/**/*",
+    "test-utils/**/*",
     "**/*.test.*"
   ]
 }