@autofleet/sequelize-utils 5.0.0

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Sequelize } from 'sequelize';
+declare const _default: (sequelize: Sequelize) => {
+    transactionWithRetry: any;
+    httpBasedTransaction: any;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 logger_1 = __importDefault(require("../../logger"));
+exports.default = (sequelize) => {
+    const transactionWithRetry = (funcToRun, retriesCount = 2) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const transValue = yield sequelize.transaction((transaction) => __awaiter(void 0, void 0, void 0, function* () {
+                const funcValue = yield funcToRun(transaction);
+                return funcValue;
+            }));
+            return transValue;
+        }
+        catch (e) {
+            if (e instanceof sequelize_1.DatabaseError) {
+                if (retriesCount === 0) {
+                    logger_1.default.error('error inside transactionWithRetry - will stop retry', e);
+                    throw e;
+                }
+                logger_1.default.error(`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, cb) => transactionWithRetry((transaction) => __awaiter(void 0, void 0, void 0, function* () {
+        req.on('aborted', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield transaction.rollback();
+        }));
+        try {
+            const response = yield cb(transaction);
+            return response;
+        }
+        catch (e) {
+            if (e.message.includes('rollback has been called on this transaction')) {
+                throw new Error('Transaction cancelled due to request cancellation');
+            }
+            throw e;
+        }
+    }));
+    return {
+        httpBasedTransaction,
+        transactionWithRetry,
+    };
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@autofleet/sequelize-utils",
+  "version": "5.0.0",
+  "description": "",
+  "main": "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"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "sequelize": "^5.22.3"
+  },
+  "devDependencies": {
+    "@types/bluebird": "^3.5.36",
+    "@types/validator": "^13.6.3",
+    "@typescript-eslint/eslint-plugin": "^4.28.3",
+    "@typescript-eslint/parser": "^4.28.3",
+    "eslint": "^7.31.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-plugin-import": "^2.23.4",
+    "ts-node": "^10.1.0",
+    "tsc": "^2.0.3",
+    "typescript": "^4.3.5"
+  }
+}

package/src/index.ts

@@ -0,0 +1,49 @@
+/* eslint-disable import/prefer-default-export */
+import { DatabaseError, Sequelize, Transaction } from 'sequelize';
+import logger from '../../logger';
+
+export default (sequelize: Sequelize): {
+  transactionWithRetry: any,
+  httpBasedTransaction: any
+} => {
+  const transactionWithRetry = async (funcToRun: any, retriesCount = 2): Promise<any> => {
+    try {
+      const transValue = await sequelize.transaction(async (transaction) => {
+        const funcValue = await funcToRun(transaction);
+        return funcValue;
+      });
+      return transValue;
+    } catch (e) {
+      if (e instanceof DatabaseError) {
+        if (retriesCount === 0) {
+          logger.error('error inside transactionWithRetry - will stop retry', e);
+          throw e;
+        }
+        logger.error(`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, cb: Function) => transactionWithRetry(async (transaction: Transaction) => {
+    req.on('aborted', async () => {
+      await transaction.rollback();
+    });
+    try {
+      const response = await cb(transaction);
+      return response;
+    } catch (e) {
+      if (e.message.includes('rollback has been called on this transaction')) {
+        throw new Error('Transaction cancelled due to request cancellation');
+      }
+      throw e;
+    }
+  });
+
+  return {
+    httpBasedTransaction,
+    transactionWithRetry,
+  };
+};

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true
+  }
+}