@autofleet/sequelize-utils 5.2.2 → 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,8 +1,14 @@
-import { Sequelize } from 'sequelize';
+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: any;
-    httpBasedTransaction: any;
-    registerModelEventHooks: any;
-    runAfterTransactionCommits: any;
+    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,97 +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 log = debug_1.default('sequelize-utils');
-const rollbackErrorText = 'rollback has been called on this transaction';
-const abortErrorText = 'Transaction cancelled due to request cancellation';
+const transaction_with_retry_1 = require("./transaction-with-retry");
+const http_based_transaction_1 = require("./http-based-transaction");
+const runAfterTransactionCommits_1 = __importDefault(require("./runAfterTransactionCommits"));
 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;
-        }
-    };
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    const httpBasedTransaction = (req, res, cb) => {
-        let aborted = false;
-        if (req.socket.destroyed) {
-            log(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, 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) => model_event_hooks_1.default(sequelize, modelTableMapping);
-    const runAfterTransactionCommits = (cb, options) => {
-        if (options.transaction) {
-            options.transaction.afterCommit(() => cb());
-        }
-        else {
-            cb();
+    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 transactionWithRetry(cb, 0);
     };
     return {
         httpBasedTransaction,
         transactionWithRetry,
         registerModelEventHooks,
-        runAfterTransactionCommits,
+        runAfterTransactionCommits: runAfterTransactionCommits_1.default,
+        useOrCreateTransaction,
     };
 };

package/dist/logger.d.ts

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

package/dist/logger.js

@@ -4,4 +4,4 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = __importDefault(require("@autofleet/logger"));
-exports.default = logger_1.default();
+exports.default = (0, logger_1.default)();

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

@@ -1,8 +1,8 @@
-import { Sequelize } from 'sequelize';
-interface ModelMapping {
+import type { Sequelize } from 'sequelize';
+export interface ModelMapping {
     [ModelName: string]: {
         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

@@ -5,48 +5,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 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 updateEventToDimTable = (object, isDelete = false) => {
+const addModelEventHooks = (sequelize, modelTableMapping) => {
+    const updateEventToDimTable = async (object, isDelete = false) => {
         try {
             const objectToSend = object.get();
             if (isDelete) {
-                objectToSend.deletedAt = new Date();
+                Object.assign(objectToSend, { deletedAt: new Date() });
             }
             const tableName = modelTableMapping[object.constructor.name]?.tableName;
             const eventVersion = '1';
             const objectToSendFormatted = formatDatesInObject(objectToSend);
             if (tableName) {
-                events_1.default.sendObject(tableName, eventVersion, objectToSendFormatted, Object.keys(object.rawAttributes));
+                await events_1.default.sendObject(tableName, eventVersion, objectToSendFormatted, 
+                // @ts-expect-error the rawAttributes is typed as static, while it actually is on the instance level.
+                Object.keys(object.rawAttributes));
             }
         }
         catch (e) {
             logger_1.default.error('dimTables error', { e });
         }
     };
-    sequelize.addHook('afterSave', async (savedObject, options) => {
-        if (options.transaction) {
-            options.transaction.afterCommit(() => updateEventToDimTable(savedObject));
-        }
-        else {
-            await updateEventToDimTable(savedObject);
-        }
-    });
-    sequelize.addHook('afterDestroy', async (savedObject, options) => {
-        if (options.transaction) {
-            options.transaction.afterCommit(() => updateEventToDimTable(savedObject, true));
-        }
-        else {
-            await updateEventToDimTable(savedObject, true);
-        }
-    });
+    sequelize.addHook('afterSave', (savedObject, options) => (0, runAfterTransactionCommits_1.default)(() => updateEventToDimTable(savedObject), options));
+    sequelize.addHook('afterDestroy', (savedObject, options) => (0, runAfterTransactionCommits_1.default)(() => updateEventToDimTable(savedObject, true), options));
 };
 exports.default = addModelEventHooks;

package/dist/runAfterTransactionCommits.d.ts

@@ -0,0 +1,3 @@
+import { Transactionable } from 'sequelize';
+declare const runAfterTransactionCommits: (cb: () => unknown, options: Transactionable) => Promise<void>;
+export default runAfterTransactionCommits;

package/dist/runAfterTransactionCommits.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runAfterTransactionCommits = async (cb, options) => {
+    if (options.transaction) {
+        options.transaction.afterCommit(() => cb());
+    }
+    else {
+        await cb();
+    }
+};
+exports.default = runAfterTransactionCommits;

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,49 +1,46 @@
 {
   "name": "@autofleet/sequelize-utils",
-  "version": "5.2.2",
+  "version": "5.2.4",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
-    "start": "ts-node  src/index.ts",
-    "example": "ts-node  src/example.ts",
-    "prepublish": "tsc",
-    "build": "tsc",
-    "lint": "./node_modules/.bin/eslint .",
-    "test": "jest --forceExit",
-    "test-local": "jest --forceExit",
-    "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage"
-  },
-  "jest": {
-    "testEnvironment": "node"
+    "start": "ts-node src/index.ts",
+    "prepublish": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json",
+    "lint": "eslint .",
+    "test": "jest",
+    "test-local": "jest",
+    "coverage": "jest --coverage --runInBand"
   },
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@autofleet/errors": "^1.1.0",
-    "@autofleet/events": "^3.0.5",
-    "@autofleet/logger": "^2.0.2",
+    "@autofleet/errors": "^1.2.3",
+    "@autofleet/events": "^3.0.7",
     "@autofleet/network": "^1.3.7",
-    "debug": "^4.3.2",
-    "jest": "^27.0.6",
-    "sequelize": "^5.22.3"
+    "debug": "^4.3.2"
+  },
+  "peerDependencies": {
+    "@autofleet/logger": ">=4",
+    "sequelize": ">=5"
   },
   "devDependencies": {
-    "@types/bluebird": "^3.5.36",
+    "@autofleet/logger": "^4.1.0",
     "@types/debug": "^4.1.6",
     "@types/express": "^4.17.13",
-    "@types/jest": "^26.0.24",
-    "@types/validator": "^13.6.3",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.6",
     "@typescript-eslint/eslint-plugin": "^4.28.3",
     "@typescript-eslint/parser": "^4.28.3",
-    "axios": "^0.26.1",
-    "bluebird": "^3.7.2",
     "eslint": "^7.31.0",
     "eslint-config-airbnb-base": "^14.2.1",
     "eslint-plugin-import": "^2.23.4",
     "express": "^4.17.3",
-    "pg": "^8.6.0",
-    "ts-jest": "^27.0.3",
+    "jest": "^29.7.0",
+    "pg": "^8.13.1",
+    "sequelize": "^5.22.3",
+    "ts-jest": "^29.2.5",
     "ts-node": "^10.1.0",
-    "typescript": "^4.3.5"
+    "typescript": "^5.5.4"
   }
 }

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,105 +1,32 @@
 /* eslint-disable import/prefer-default-export */
-import {
-  DatabaseError,
+import type {
   Sequelize,
   Transaction,
-  Transactionable,
+  TransactionOptions,
 } from 'sequelize';
-import debug from 'debug';
-import addModelEventHooks from './model-event-hooks';
+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: any,
-  httpBasedTransaction: any,
-  registerModelEventHooks: any,
-  runAfterTransactionCommits: any,
+  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 (funcToRun: any, retriesCount = 2, options?: any): Promise<any> => {
-    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;
-    }
-  };
-
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  const httpBasedTransaction = (req: any, res: any, cb: Function) => {
-    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) => addModelEventHooks(sequelize, modelTableMapping);
-
-  const runAfterTransactionCommits = (cb: () => any, options: Transactionable) => {
-    if (options.transaction) {
-      options.transaction.afterCommit(() => cb());
-    } else {
-      cb();
+  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);
   };
 
   return {
@@ -107,5 +34,6 @@ export default (sequelize: Sequelize): {
     transactionWithRetry,
     registerModelEventHooks,
     runAfterTransactionCommits,
+    useOrCreateTransaction,
   };
 };

package/src/model-event-hooks.ts

@@ -1,38 +1,39 @@
-import { Sequelize } from 'sequelize';
+import type { Model, Sequelize } from 'sequelize';
 import events from './events';
 import logger from './logger';
+import runAfterTransactionCommits from './runAfterTransactionCommits';
 
-interface ModelMapping {
+export interface ModelMapping {
   [ModelName: string]: {
     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) => {
-  const updateEventToDimTable = (object, isDelete = false) => {
+const addModelEventHooks = (sequelize: Sequelize, modelTableMapping: ModelMapping): void => {
+  const updateEventToDimTable = async (object: Model, isDelete = false) => {
     try {
       const objectToSend = object.get();
       if (isDelete) {
-        objectToSend.deletedAt = new Date();
+        Object.assign(objectToSend, { deletedAt: new Date() });
       }
       const tableName = modelTableMapping[object.constructor.name]?.tableName;
       const eventVersion = '1';
       const objectToSendFormatted = formatDatesInObject(objectToSend);
       if (tableName) {
-        events.sendObject(
+        await events.sendObject(
           tableName,
           eventVersion,
           objectToSendFormatted,
+          // @ts-expect-error the rawAttributes is typed as static, while it actually is on the instance level.
           Object.keys(object.rawAttributes),
         );
       }
@@ -41,20 +42,8 @@ const addModelEventHooks = async (sequelize: Sequelize, modelTableMapping: Model
     }
   };
 
-  sequelize.addHook('afterSave', async (savedObject, options) => {
-    if (options.transaction) {
-      options.transaction.afterCommit(() => updateEventToDimTable(savedObject));
-    } else {
-      await updateEventToDimTable(savedObject);
-    }
-  });
-  sequelize.addHook('afterDestroy', async (savedObject, options) => {
-    if (options.transaction) {
-      options.transaction.afterCommit(() => updateEventToDimTable(savedObject, true));
-    } else {
-      await updateEventToDimTable(savedObject, true);
-    }
-  });
+  sequelize.addHook('afterSave', (savedObject, options) => runAfterTransactionCommits(() => updateEventToDimTable(savedObject), options));
+  sequelize.addHook('afterDestroy', (savedObject, options) => runAfterTransactionCommits(() => updateEventToDimTable(savedObject, true), options));
 };
 
 export default addModelEventHooks;

package/src/runAfterTransactionCommits.ts

@@ -0,0 +1,10 @@
+import { Transactionable } from 'sequelize';
+
+const runAfterTransactionCommits = async (cb: () => unknown, options: Transactionable): Promise<void> => {
+  if (options.transaction) {
+    options.transaction.afterCommit(() => cb());
+  } else {
+    await cb();
+  }
+};
+export default runAfterTransactionCommits;

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

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "node_modules",
+    "dist/**/*",
+    "test-utils/**/*",
+    "**/*.test.*"
+  ]
+}

package/tsconfig.json

@@ -5,6 +5,12 @@
     "declaration": true,
     "outDir": "./dist",
     "strict": false,
-    "esModuleInterop": true
-  }
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": [
+    "node_modules",
+    "dist/**/*"
+  ]
 }