@autofleet/sequelize-utils 5.2.2 → 5.2.3

package/dist/index.d.ts

@@ -1,8 +1,11 @@
-import { Sequelize } from 'sequelize';
+import { Sequelize, Transaction, TransactionOptions } from 'sequelize';
+import type { IncomingMessage, ServerResponse } from 'http';
+import { ModelMapping } from './model-event-hooks';
+import runAfterTransactionCommits from './runAfterTransactionCommits';
 declare const _default: (sequelize: Sequelize) => {
-    transactionWithRetry: any;
-    httpBasedTransaction: any;
-    registerModelEventHooks: any;
-    runAfterTransactionCommits: any;
+    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>;
+    runAfterTransactionCommits: typeof runAfterTransactionCommits;
 };
 export default _default;

package/dist/index.js

@@ -7,13 +7,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 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) => {
+    const transactionWithRetry = async (funcToRun, retriesCount = 2, options = {}) => {
         try {
-            const transValue = await sequelize.transaction(options || {}, async (transaction) => {
+            const transValue = await sequelize.transaction(options, async (transaction) => {
                 const funcValue = await funcToRun(transaction);
                 return funcValue;
             });
@@ -31,7 +32,6 @@ exports.default = (sequelize) => {
             throw e;
         }
     };
-    // eslint-disable-next-line @typescript-eslint/ban-types
     const httpBasedTransaction = (req, res, cb) => {
         let aborted = false;
         if (req.socket.destroyed) {
@@ -81,19 +81,11 @@ exports.default = (sequelize) => {
             }
         });
     };
-    const registerModelEventHooks = (modelTableMapping) => model_event_hooks_1.default(sequelize, modelTableMapping);
-    const runAfterTransactionCommits = (cb, options) => {
-        if (options.transaction) {
-            options.transaction.afterCommit(() => cb());
-        }
-        else {
-            cb();
-        }
-    };
+    const registerModelEventHooks = (modelTableMapping) => (0, model_event_hooks_1.default)(sequelize, modelTableMapping);
     return {
         httpBasedTransaction,
         transactionWithRetry,
         registerModelEventHooks,
-        runAfterTransactionCommits,
+        runAfterTransactionCommits: runAfterTransactionCommits_1.default,
     };
 };

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

package/dist/model-event-hooks.js

@@ -5,6 +5,7 @@ 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 formatDatesInObject = (obj) => {
     const newObj = { ...obj };
     Object.keys(newObj).forEach((key) => {
@@ -15,38 +16,26 @@ const formatDatesInObject = (obj) => {
     return newObj;
 };
 const addModelEventHooks = async (sequelize, modelTableMapping) => {
-    const updateEventToDimTable = (object, isDelete = false) => {
+    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/package.json

@@ -1,49 +1,46 @@
 {
   "name": "@autofleet/sequelize-utils",
-  "version": "5.2.2",
+  "version": "5.2.3",
   "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 .",
+    "start": "ts-node src/index.ts",
+    "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 && rm -rf ./coverage"
-  },
-  "jest": {
-    "testEnvironment": "node"
+    "coverage": "jest --coverage --forceExit --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/index.ts

@@ -3,10 +3,12 @@ import {
   DatabaseError,
   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 runAfterTransactionCommits from './runAfterTransactionCommits';
 
 const log = debug('sequelize-utils');
 
@@ -14,18 +16,17 @@ const rollbackErrorText = 'rollback has been called on this transaction';
 const abortErrorText = 'Transaction cancelled due to request cancellation';
 
 export default (sequelize: Sequelize): {
-  transactionWithRetry: any,
-  httpBasedTransaction: any,
-  registerModelEventHooks: any,
-  runAfterTransactionCommits: any,
+  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>;
+  runAfterTransactionCommits: typeof runAfterTransactionCommits;
 } => {
-  const transactionWithRetry = async (funcToRun: any, retriesCount = 2, options?: any): Promise<any> => {
+  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;
-        });
+      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') {
@@ -40,8 +41,7 @@ export default (sequelize: Sequelize): {
     }
   };
 
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  const httpBasedTransaction = (req: any, res: any, cb: Function) => {
+  const httpBasedTransaction = <T>(req: IncomingMessage, res: ServerResponse, cb: (transaction: Transaction) => Promise<T>): Promise<T> => {
     let aborted = false;
     if (req.socket.destroyed) {
       log(abortErrorText);
@@ -92,15 +92,7 @@ export default (sequelize: Sequelize): {
     });
   };
 
-  const registerModelEventHooks = (modelTableMapping) => addModelEventHooks(sequelize, modelTableMapping);
-
-  const runAfterTransactionCommits = (cb: () => any, options: Transactionable) => {
-    if (options.transaction) {
-      options.transaction.afterCommit(() => cb());
-    } else {
-      cb();
-    }
-  };
+  const registerModelEventHooks = (modelTableMapping: ModelMapping) => addModelEventHooks(sequelize, modelTableMapping);
 
   return {
     httpBasedTransaction,

package/src/model-event-hooks.ts

@@ -1,8 +1,9 @@
-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
   };
@@ -18,21 +19,22 @@ const formatDatesInObject = (obj: any) => {
   return newObj;
 };
 
-const addModelEventHooks = async (sequelize: Sequelize, modelTableMapping: ModelMapping) => {
-  const updateEventToDimTable = (object, isDelete = false) => {
+const addModelEventHooks = async (sequelize: Sequelize, modelTableMapping: ModelMapping): Promise<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 +43,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/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "node_modules",
+    "dist/**/*",
+    "**/*.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/**/*"
+  ]
 }