@sera4/essentia 1.1.11 → 1.1.14

package/README.md

@@ -7,3 +7,4 @@ A collection of small modules providing essential utilities for TWS services:
 * A logging tool
 * An HTTP response tool for consistenty formatting error responses
 * A small utility to dump the last commit of the project
+* [Paper Trail](paper-trail/README.md)

package/cache/index.js

@@ -0,0 +1,188 @@
+"use strict"
+
+import { promisify } from "util";
+
+const isEmpty = obj => [Object, Array].includes((obj || {}).constructor) && !Object.entries((obj || {})).length;
+
+class CacheConfigError extends Error {
+  constructor(m) {
+    super(m);
+  }
+}
+
+/* Redis cache helper
+ * Example use: Place the following code in your project to setup redis use
+ *
+ *    import { cache } from "@sera4/essentia";
+ *    const cacheHelper = cache({ password: .., database: .., host: .., port: .. }, "service:"));
+ *
+ */
+
+const convertRedisKeyValueToJson = (v) => {
+  return (v && v.length > 0 && v[0] !== null) ? JSON.parse(v) : null;
+}
+
+const convertRedisHashToJson = (v) => {
+  if (v) {
+    var result = {};
+    for(var k in v) {
+      if (v.hasOwnProperty(k)) {
+        result[k] = JSON.parse(v[k]);
+      }
+    }
+    return result;
+  } else {
+    return null;
+  }
+}
+
+function convertJsonToRedisValue(j) {
+  var result = {};
+  for (var key in j) {
+    if (j.hasOwnProperty(key)) {
+      result[key] = JSON.stringify(j[key]);
+    }
+  }
+  return result;
+}
+
+class Cache {
+  constructor(config, servicePrefix) {
+    if ((config == undefined) || isEmpty(config)) {
+      throw new CacheConfigError("Invalid cache configuration");
+    }
+
+    if (servicePrefix == null) {
+      throw new CacheConfigError("Invalid service prefix");
+    }
+
+    if (config.fake) {
+      // used in testing
+      this.redisClient = require("fakeredis").createClient("fake backend")
+    } else {
+      this.redisClient = require("redis").createClient(config);
+    }
+
+    this.redisClient.on("error", (err) => {
+      logger.error("Cache/Redis error: ", err);
+    });
+
+    this.servicePrefix = servicePrefix;
+  }
+
+  ping() {
+    return this.redisClient.ping();
+  }
+
+  properKey(key, path) {
+    let p = this.servicePrefix + key
+    if (path)
+      p += path
+    return p
+  }
+
+  writeHash(path, key, value) {
+    return this.redisClient.hsetAsync(properKey(key), key, value);
+  }
+
+  writeHashBlocking(path, key, value) {
+    return this.redisClient.hset(properKey(key), key, value);
+  }
+
+  // write multiple hash keys and stringify every value
+  writeMultiHash(path, j) {
+    return this.redisClient.hmsetAsync(properKey(key), convertJsonToRedisValue(j));
+  }
+
+  readHashKey(obj, key, autoConvert=true) {
+    var k = autoConvert;
+
+    return new Promise((resolve, reject) => {
+      this.redisClient.hget(properKey(key, obj), key, (e, r) => {
+        if (e) {
+          logger.error("Redis hmget error:", e);
+          reject(e);
+        } else {
+          resolve(k ? convertRedisKeyValueToJson(r) : r);
+        }
+      });
+    });
+  }
+
+  readHash(path) {
+    return new Promise((resolve, reject) => {
+      this.redisClient.hgetall(properKey(key, path), (e, r) => {
+        if (e) {
+          console.log("Redis hget error:", e);
+          reject(e);
+        } else {
+          resolve(convertRedisHashToJson(r));
+        }
+      });
+    });
+  }
+
+  deleteHashKey(hash, key) {
+    return new Promise((resolve, reject) => {
+      this.redisClient.hdel(properKey(key, hash), key, (err) => {
+        if (err) {
+          logger.error("Redis hdel error:", err);
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  get(key) {
+    return this.redisClient.getAsync(properKey(key));
+  }
+
+  getAsync(key) {
+    return promisify(this.redisClient.get(key)).bind(this.redisClient)
+  }
+
+
+  /* a single key write with optional expiry */
+  // returns bluebird promise
+  writeKey(key, value, expiry) {
+    key = this.servicePrefix + key;
+    if (expiry) {
+      return this.redisClient.setAsync(key, value, "EX", expiry);
+    } else {
+      return this.redisClient.setAsync(key, value);
+    }
+  }
+
+  deleteKey(key) {
+    return redisClient.delAsync(properKey(key));
+  }
+
+  expire(path, expiry) {
+    return this.redisClient.expire(path, expiry);
+  }
+
+  exists(path) {
+    return this.redisClient.exists(path);
+  }
+
+  deleteAllKeys() {
+    return new Promise((resolve, reject) => {
+      if(process.env.NODE_ENV === "production") {
+        throw new Error("Clearing system cache is not permitted in production");
+      }
+      this.redisClient.flushdb((err, res) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(res);
+        }
+      });
+    });
+  }
+}
+
+export default function(config, servicePrefix) {
+  return new Cache(config, servicePrefix)
+}

package/health/health-logger.js

@@ -0,0 +1,40 @@
+import logger from "../logger/s4-logger.js";
+let enabled = false;
+
+const helpers = {
+  debug(...args) {
+    if (enabled) {
+      logger.debug(":: HealthCheck ::", args);
+    }
+  },
+
+  log(...args) {
+    if (enabled) {
+      logger.debug(":: HealthCheck ::", args);
+    }
+  },
+
+  warn(...args) {
+    if (enabled) {
+      logger.warn(":: HealthCheck ::", args);
+    }
+  },
+
+  info(...args) {
+    if (enabled) {
+      logger.info(":: HealthCheck ::", args);
+    }
+  },
+
+  error(...args) {
+    if (enabled) {
+      logger.error(":: HealthCheck ::", args);
+    }
+  },
+
+  setEnabled(e) {
+    enabled = e;
+  }
+}
+
+export default helpers;

package/health/index.js

@@ -1,6 +1,7 @@
 "use strict"
 
 import pathHelper from "path";
+import logger from "./health-logger.js";
 
 class HealthCheckError extends Error {
   constructor(m) {
@@ -15,12 +16,16 @@ class HealthCheckError extends Error {
  *    const router = require('express').Router();
  *
  *      ....
+ *
+ *    const checkRedis = async () => { await cache.ping(); }
+ *    hc.setupCheck({ name: "redis", checkResult: false, critical: true, healthFunction: checkRedis });
  *    app.use(hc.defaultPath(serverConfigs.api_prefix), hc.routes(router));
  *
  */
-
 class HealthCheck {
-  constructor(appendData = {}) {
+  constructor(appendData = {}, enableLogging = true) {
+    logger.setEnabled(enableLogging);
+
     this.defaultResponse = {
       ...
       appendData,
@@ -29,11 +34,13 @@ class HealthCheck {
     };
 
     this.defaultPathRoute = `health_check\(.*\)?`
+    this.suppressLogs = false;
     this.lastCallId = 0; // default start point/integer
     this.healthChecks = [];
   }
 
-  /* call this with an async function, must support wait capability
+  /* Deprecated and replaced by setupCheck
+   *   call this with an async function, must support wait capability
    *
    *   const dbCheck = async () => {
    *     return { name: "db", "result": "success", critical: false };
@@ -60,15 +67,40 @@ class HealthCheck {
     return router
   }
 
-  /* performs health checks and returns 200 if true and 500 if not */
+  // v2 version of health check, replaced addCheck
+  // example:
+  //  const checkRedisFcn = async () => { await cache.ping().then(() => true) }
+  //  setupCheck({ name: "redis", checkResult: false, critical: false, healthFunction: checkRedisFcn });
+  setupCheck(config) {
+    this.healthChecks.push(config);
+  }
+
+  /* performs health checks and returns 200 if true and 500 if not */ 
   async checkHealth(req, res) {
     const checkFormat = pathHelper.extname(req.baseUrl);
 
-    try {
-      const result = await Promise.all(this.healthChecks.map(async healthCallback => {
-        return await healthCallback();
-      }));
+    const result = await Promise.all(this.healthChecks.map(async hc => {
+      if (typeof(hc) === "function") {
+        try {
+          return await hc();
+          return { "result": "success", critical: false };
+        } catch(e) {
+          return  { name: "unknown", result: 'fail', status: e.status }
+        }
+      } else {
+        let res = { name: hc.name, critical: hc.critical }
+        try {
+          await hc.healthFunction();
+          return { ...res, "result": "success" };
+        } catch(e) {
+          const appendStatus = e.status ? ` (${e.status})` : ""
+          logger.warn(`${hc.name} service failed${appendStatus}` )
+          return { ...res, "result": "fail", status: e.status } 
+        }
+      }
+    }));
 
+    try {
       let callId = ++this.lastCallId;
 
       // start the counter over
@@ -78,10 +110,18 @@ class HealthCheck {
 
       let status = this.defaultResponse.status;
 
+      let nonCriticalFail = false;
+      let criticalFail = false;
+
       result.some(e => {
         if (e.result.match(/fail/)) {
-          status = 500;
-          return true; // break
+          if (e.critical == false) {
+            nonCriticalFail = true;
+          } else {
+            criticalFail = true;
+            status = 500;
+            return true; // break
+          }
         }
       })
 
@@ -89,33 +129,36 @@ class HealthCheck {
       res.setHeader('check', callId)
 
       if (checkFormat === ".json") {
-        const payload = { "check": callId }
+        const payload = { "check": callId, healthy: "true", message: "success" }
 
-        if (status === 200) {
+        if (criticalFail) {
           res.status(status).json({
             ... payload,
-            "healthy":true,
-            "message":"success"
+            "healthy": false,
+            "message": "fail",
+            "services": result
           });
-        } else {
+        } else if (nonCriticalFail) {
           res.status(status).json({
             ... payload,
-            "healthy": false,
             "message": "fail",
-            "services": [result]
+            "services": result
           });
+        } else if (status === 200) {
+          res.status(status).json(payload);
         }
       } else {
         let status_message;
-        if (status === 200) {
-          status_message = "success"
-        } else {
+        if (criticalFail) {
           status_message = "fail"
-        }
+        } else if ((status === 200) || nonCriticalFail) {
+          status_message = "success"
+        } 
 
         res.status(status).send(status_message);
       }
     } catch(error) {
+      console.debug("error: ", error)
       res.status(500).send();
     }
   }

package/index.js

@@ -8,5 +8,6 @@ export { default as halDecorator } from "./hal/index.js";
 export { default as formatter } from "./formatter/index.js";
 export { HealthCheck as healthCheck } from "./health/index.js";
 export { default as queue } from "./queue/index.js";
+export { default as paperTrail } from "./paper-trail/index.js";
 export * from "./utils/index.js";
 export * from "./safe_proxy/index.js";

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@sera4/essentia",
-  "version": "1.1.11",
+  "version": "1.1.14",
   "description": "A library of utilities for Teleporte Web Services",
   "main": "index.js",
   "type": "module",
   "scripts": {
     "test": "NODE_ENV=test ./node_modules/.bin/mocha --forbid-only --reporter mocha-junit-reporter --reporter-options mochaFile=./test-results/result.xml --exit",
-    "test:dev": "NODE_ENV=test ./node_modules/.bin/mocha --watch --forbid-only",
+    "test:dev": "NODE_ENV=test ./node_modules/.bin/mocha --forbid-only",
     "test:only": "NODE_ENV=test ./node_modules/.bin/mocha --watch",
     "test:pretty": "NODE_ENV=test ./node_modules/.bin/mocha --reporter mocha-simple-html-reporter --reporter-options output=./test-results/result.html --exit",
     "last-commit": "node last-commit.js"
@@ -30,11 +30,12 @@
   "dependencies": {
     "amqplib": "^0.8.0",
     "async": "^2.6.3",
-    "axios": "^0.21.1",
+    "axios": "^0.21.4",
+    "deep-diff": "^1.0.2",
     "fast-safe-stringify": "^2.0.7",
     "git-rev": "^0.2.1",
     "lodash": "^4.17.21",
-    "url-parse": "^1.5.1",
+    "url-parse": "^1.5.3",
     "uuid": "^3.4.0",
     "winston": "^3.3.3",
     "winston-logstash": "^0.4.0"

package/paper-trail/README.md

@@ -0,0 +1,67 @@
+# Sequelize Paper Trail
+
+A paper trail/sequelize hook plugin.  This plugin has been modified to use the node14 CLS API called AsyncLocalStorage as well as fix some of the postgres related bugs.  We have kept our own implemnetation and various changes were needed to support the express framework and pushing this to the public would hinder the general usability of this library for all.
+
+## Usage
+
+In your database setup, setup your models and then attach the paperTrail to them.  Many default options need to be changed to support underscore notation and the use of Account instead of User as the default table, thus suggestions options for TWS projects are shown below.
+
+```
+import { paperTrail } from "@sera4/essentia"
+import Sequelize from 'sequelize';
+
+...
+
+const sequelize = new Sequelize(...);
+
+PaperTrail.init(sequelize, Sequelize, { UUID: true,
+  underscored: true, enableMigration: true, underscoredAttributes: true,
+  debug: false, userModel: 'Account', enableCompression: true });
+};
+
+const db = {};
+// for any model you want enabled
+db["Tenant"]            = TenantModel(sequelize, Sequelize);
+
+db.PaperTrail = PaperTrail.init(sequelize, Sequelize, { UUID: true, underscored: true,
+  enableMigration: true, underscoredAttributes: true, continuationKey: "accountId",
+  debug: false, userModel: 'Account', userModelAttribute: 'account_id',
+  enableCompression: true });
+
+db.PaperTrail.defineModels();
+
+.. and for any model that needs a papertrail, call hasPaperTrail() on it ..
+db["Tenant"].hasPaperTrail();
+db["TenantLicense"].hasPaperTrail();
+```
+
+and similarly, to use the automatic ALS (asyncLocalStorage) for automatic setting of the account/userID - add this into your middleware
+
+```
+import db from "../database/models/index.js";
+
+let alsEnabled = db.PaperTrail.alsEnabled();
+
+const localStorageMiddleware = async (req, res, next) => {
+  await asyncLocalStorage.run(new Map(), () => {
+    if (!alsEnabled) {
+      alsEnabled = true;
+      db.PaperTrail.setupALS(asyncLocalStorage);
+    }
+
+    next();
+  });
+};
+```
+as this will ensure that the ALS context is initialized AFTER the first `run()` invocation.
+
+`Please note`: For automatic accountId fetching, it is imperitive that you add
+
+```
+  asyncLocalStorage.getStore().set("accountId", accountId);
+```
+somewhere into your express middleware so the database hooks can pickup the accountId when changes are made.
+
+## History
+
+This is a private fork/implementation of https://github.com/nielsgl/sequelize-paper-trail which has been released under MIT license.  This was privitized due to the number of commented out items/untested in their project as well as the change from CLS (continuation-local-storage) which is experimental to the supported AsyncLocalStorage which was stabilized in Node 14 as the CLS API 101.

package/paper-trail/helpers.js

@@ -0,0 +1,99 @@
+import pkg from 'deep-diff';
+import _ from 'lodash';
+
+const { diff } = pkg;
+const capitalizeFirstLetter = string =>
+	string.charAt(0).toUpperCase() + string.slice(1);
+
+const toUnderscored = obj => {
+	_.forEach(obj, (k, v) => {
+		obj[k] = v
+			.replace(/(?:^|\.?)([A-Z])/g, (x, y) => `_${y.toLowerCase()}`)
+			.replace(/^_/, '');
+	});
+	return obj;
+};
+
+const calcDelta = (current, next, exclude, strict, DEBUG = false) => {
+	if (DEBUG) {
+		console.log('current', current);
+		console.log('next', next);
+		console.log('exclude', exclude);
+	}
+
+	const di = diff(current, next);
+
+	if (DEBUG) {
+		console.log('di', di);
+
+		let diffs2 = [];
+		if (di) {
+			diffs2 = di.map(i =>
+				JSON.parse(JSON.stringify(i).replace('"__data",', '')),
+			);
+		}
+
+		console.log('diffs2', diffs2);
+
+		console.log(
+			'filter1',
+			diffs2.filter(i => i.path.join(',').indexOf('_') === -1),
+		);
+
+		console.log(
+			'filter2',
+			diffs2.filter(i => exclude.every(x => i.path.indexOf(x) === -1)),
+		);
+	}
+
+	let diffs = [];
+	if (di) {
+		diffs = di
+			.map(i => JSON.parse(JSON.stringify(i).replace('"__data",', '')))
+			.filter(i => {
+				if (!strict && i.kind === 'E') {
+					// eslint-disable-next-line eqeqeq
+					if (i.lhs != i.rhs) return i;
+				} else return i;
+				return false;
+			})
+			.filter(i => exclude.every(x => i.path.indexOf(x) === -1));
+	}
+
+	if (diffs.length > 0) {
+		return diffs;
+	}
+	return null;
+};
+
+const diffToString = val => {
+	if (typeof val === 'undefined' || val === null) 
+		return '';
+
+	if (val === true)
+		return '1';
+
+	if (val === false) 
+		return '0';
+
+	if (typeof val === 'string') 
+		return val;
+
+	if (!Number.isNaN(Number(val))) 
+		return `${String(val)}`;
+
+	if ((typeof val === 'undefined' ? 'undefined' : typeof val) === 'object') 
+		return `${JSON.stringify(val)}`;
+
+	if (Array.isArray(val)) 
+		return `${JSON.stringify(val)}`;
+
+	return '';
+};
+
+export default {
+	capitalizeFirstLetter,
+	toUnderscored,
+	calcDelta,
+	diffToString,
+};

package/paper-trail/index.js

@@ -0,0 +1,637 @@
+import * as jsdiff from 'diff';
+import _ from 'lodash';
+import helpers from './helpers.js';
+// import Sequelize from 'sequelize';
+
+let failHard = false;
+let als;
+let Sequelize = null
+
+const paperTrail = {};
+
+paperTrail.init = (sequelize, sequelizePackage, optionsArg) => {
+	Sequelize = sequelizePackage;
+	// In case that options is being parsed as a readonly attribute.
+	// Or it is not passed at all
+	const optsArg = _.cloneDeep(optionsArg || {});
+
+	const defaultOptions = {
+		debug: false,
+		log: null,
+		exclude: [
+			'id',
+			'createdAt',
+			'updatedAt',
+			'deletedAt',
+			'created_at',
+			'updated_at',
+			'deleted_at',
+			'revision',
+		],
+		revisionAttribute: 'revision',
+		revisionModel: 'Revision',
+		revisionChangeModel: 'RevisionChange',
+		enableRevisionChangeModel: false,
+		UUID: false,
+		underscored: false,
+		underscoredAttributes: false,
+		defaultAttributes: {
+			documentId: 'documentId',
+			revisionId: 'revisionId',
+		},
+		als: null,
+		userModel: false,
+		userModelAttribute: 'userId',
+		enableCompression: false,
+		enableMigration: false,
+		enableStrictDiff: true,
+		continuationNamespace: null,
+		continuationKey: 'userId',
+		metaDataFields: null,
+		metaDataContinuationKey: 'metaData',
+		mysql: false,
+	};
+
+	if (optsArg.underscoredAttributes) {
+		helpers.toUnderscored(defaultOptions.defaultAttributes);
+	}
+
+	const options = _.defaults(optsArg, defaultOptions);
+
+	const log = options.log || console.log;
+
+	function createBeforeHook(operation) {
+
+		const beforeHook = function beforeHook(instance, opt) {
+			if (options.debug) {
+				log('beforeHook called');
+				log('instance:', instance);
+				log('opt:', opt);
+			}
+
+			if (opt.noPaperTrail) {
+				if (options.debug) {
+					log('noPaperTrail opt: is true, not logging');
+				}
+				return;
+			}
+
+			const destroyOperation = operation === 'destroy';
+
+			let previousVersion = {};
+			let currentVersion = {};
+			if (!destroyOperation && options.enableCompression) {
+				_.forEach(opt.defaultFields, a => {
+					previousVersion[a] = instance._previousDataValues[a];
+					currentVersion[a] = instance.dataValues[a];
+				});
+			} else {
+				previousVersion = instance._previousDataValues;
+				currentVersion = instance.dataValues;
+			}
+			// Supported nested models.
+			previousVersion = _.omitBy(
+				previousVersion,
+				i => i != null && typeof i === 'object' && !(i instanceof Date),
+			);
+			previousVersion = _.omit(previousVersion, options.exclude);
+
+			currentVersion = _.omitBy(
+				currentVersion,
+				i => i != null && typeof i === 'object' && !(i instanceof Date),
+			);
+			currentVersion = _.omit(currentVersion, options.exclude);
+
+			// Disallow change of revision
+			instance.set(
+				options.revisionAttribute,
+				instance._previousDataValues[options.revisionAttribute],
+			);
+
+			// Get diffs
+			const delta = helpers.calcDelta(
+				previousVersion,
+				currentVersion,
+				options.exclude,
+				options.enableStrictDiff,
+			);
+
+			const currentRevisionId = instance.get(options.revisionAttribute);
+
+			if (failHard && !currentRevisionId && opt.type === 'UPDATE') {
+				throw new Error('Revision Id was undefined');
+			}
+
+			if (options.debug) {
+				log('delta:', delta);
+				log('revisionId', currentRevisionId);
+			}
+			// Check if all required fields have been provided to the opts / ALS
+			if (options.metaDataFields) {
+				// get all required field keys as an array
+				const requiredFields = _.keys(
+					_.pickBy(
+						options.metaDataFields,
+						function isMetaDataFieldRequired(required) {
+							return required;
+						},
+					),
+				);
+				if (requiredFields && requiredFields.length) {
+          const store = options.als && options.als.getStore();
+					const metaData = (store && store.get(metaDataContinuationKey)) || opt.metaData
+					const requiredFieldsProvided = _.filter(
+						requiredFields,
+						function isMetaDataFieldNonUndefined(field) {
+							return metaData[field] !== undefined;
+						},
+					);
+					if (
+						requiredFieldsProvided.length !== requiredFields.length
+					) {
+						log(
+							'Required fields: ',
+							options.metaDataFields,
+							requiredFields,
+						);
+						log(
+							'Required fields provided: ',
+							metaData,
+							requiredFieldsProvided,
+						);
+						throw new Error(
+							'Not all required fields are provided to paper trail!',
+						);
+					}
+				}
+			}
+
+			if (destroyOperation || (delta && delta.length > 0)) {
+				const revisionId = (currentRevisionId || 0) + 1;
+				instance.set(options.revisionAttribute, revisionId);
+
+				if (!instance.context) {
+					instance.context = {};
+				}
+				instance.context.delta = delta;
+			}
+
+			if (options.debug) {
+				log('end of beforeHook');
+			}
+		};
+		return beforeHook;
+	}
+
+	function createAfterHook(operation) {
+		const afterHook = function afterHook(instance, opt) {
+			const store = options.als && options.als.getStore()
+			if (options.debug) {
+				log('afterHook called');
+				log('instance:', instance);
+				log('opt:', opt);
+
+				if (store) {
+					log(
+						`ALS ${options.continuationKey}:`,
+						store.get(options.continuationKey),
+					);
+				}
+			}
+
+			const destroyOperation = operation === 'destroy';
+
+			if (
+				instance.context &&
+				((instance.context.delta &&
+					instance.context.delta.length > 0) ||
+					destroyOperation)
+			) {
+				const Revision = sequelize.model(options.revisionModel);
+				let RevisionChange;
+
+				if (options.enableRevisionChangeModel) {
+					RevisionChange = sequelize.model(
+						options.revisionChangeModel,
+					);
+				}
+
+				const { delta } = instance.context;
+
+				let previousVersion = {};
+				let currentVersion = {};
+				if (!destroyOperation && options.enableCompression) {
+					_.forEach(opt.defaultFields, a => {
+						previousVersion[a] = instance._previousDataValues[a];
+						currentVersion[a] = instance.dataValues[a];
+					});
+				} else {
+					previousVersion = instance._previousDataValues;
+					currentVersion = instance.dataValues;
+				}
+
+				// Supported nested models.
+				previousVersion = _.omitBy(
+					previousVersion,
+					i =>
+						i != null &&
+						typeof i === 'object' &&
+						!(i instanceof Date),
+				);
+				previousVersion = _.omit(previousVersion, options.exclude);
+
+				currentVersion = _.omitBy(
+					currentVersion,
+					i =>
+						i != null &&
+						typeof i === 'object' &&
+						!(i instanceof Date),
+				);
+				currentVersion = _.omit(currentVersion, options.exclude);
+
+				if (!options.als)
+					options.als = asyncLocalStorage;
+
+        const store = options.als && options.als.getStore()
+				if (store && !store.has(options.continuationKey)) {
+					if (failHard)
+						throw new Error(
+							`The ALS continuationKey ${options.continuationKey} was not defined.`,
+						);
+				}
+
+				let document = currentVersion;
+
+				if (options.mysql) {
+					document = JSON.stringify(document);
+				}
+
+				// Build revision
+				const query = {
+					model: this.name,
+					document,
+					operation,
+				};
+
+				// Add all extra data fields to the query object
+				if (options.metaDataFields) {
+					const metaData =
+						(store && store.get(options.metaDataContinuationKey)) ||
+						opt.metaData;
+					if (metaData) {
+						_.forEach(
+							options.metaDataFields,
+							function getMetaDataValues(required, field) {
+								const value = metaData[field];
+								if (options.debug) {
+									log(
+										`Adding metaData field to Revision - ${field} => ${value}`,
+									);
+								}
+								if (!(field in query)) {
+									query[field] = value;
+								} else if (options.debug) {
+									log(
+										`Revision object already has a value at ${field} => ${query[field]}`,
+									);
+									log('Not overwriting the original value');
+								}
+							},
+						);
+					}
+				}
+
+				// in case of custom user models that are not 'userId'
+				query[options.userModelAttribute] =
+					(store && store.get(options.continuationKey)) || opt.userId;
+
+				query[options.defaultAttributes.documentId] = instance.id;
+
+				const revision = Revision.build(query);
+
+				revision[options.revisionAttribute] = instance.get(
+					options.revisionAttribute,
+				);
+
+				// Save revision(
+				return revision
+					.save({ transaction: opt.transaction })
+					.then(objectRevision => {
+						// Loop diffs and create a revision-diff for each
+						if (options.enableRevisionChangeModel) {
+							_.forEach(delta, difference => {
+								const o = helpers.diffToString(
+									difference.item
+										? difference.item.lhs
+										: difference.lhs,
+								);
+								const n = helpers.diffToString(
+									difference.item
+										? difference.item.rhs
+										: difference.rhs,
+								);
+
+								// let document = difference;
+								document = difference;
+								let diff = o || n ? jsdiff.diffChars(o, n) : [];
+
+								if (options.mysql) {
+									document = JSON.stringify(document);
+									diff = JSON.stringify(diff);
+								}
+
+								const d = RevisionChange.build({
+									path: difference.path[0],
+									document,
+									diff,
+									revisionId: objectRevision.id,
+								});
+
+								d.save({ transaction: opt.transaction })
+									.then(savedD => {
+										// Add diff to revision
+										objectRevision[
+											`add${helpers.capitalizeFirstLetter(
+												options.revisionChangeModel,
+											)}`
+										](savedD);
+
+										return null;
+									})
+									.catch(err => {
+										log('RevisionChange save error', err);
+										throw err;
+									});
+							});
+						}
+						return null;
+					})
+					.catch(err => {
+						log('Revision save error', err);
+						throw err;
+					});
+			}
+
+			if (options.debug) {
+				log('end of afterHook');
+			}
+
+			return null;
+		};
+		return afterHook;
+	}
+
+	// order in which sequelize processes the hooks
+	// (1)
+	// beforeBulkCreate(instances, options, fn)
+	// beforeBulkDestroy(instances, options, fn)
+	// beforeBulkUpdate(instances, options, fn)
+	// (2)
+	// beforeValidate(instance, options, fn)
+	// (-)
+	// validate
+	// (3)
+	// afterValidate(instance, options, fn)
+	// - or -
+	// validationFailed(instance, options, error, fn)
+	// (4)
+	// beforeCreate(instance, options, fn)
+	// beforeDestroy(instance, options, fn)
+	// beforeUpdate(instance, options, fn)
+	// (-)
+	// create
+	// destroy
+	// update
+	// (5)
+	// afterCreate(instance, options, fn)
+	// afterDestroy(instance, options, fn)
+	// afterUpdate(instance, options, fn)
+	// (6)
+	// afterBulkCreate(instances, options, fn)
+	// afterBulkDestroy(instances, options, fn)
+	// afterBulkUpdate(instances, options, fn)
+
+	// Extend model prototype with "hasPaperTrail" function
+	// Call model.hasPaperTrail() to enable revisions for model
+	_.assignIn(Sequelize.Model, {
+		hasPaperTrail: function hasPaperTrail() {
+			if (options.debug) {
+				log('Enabling paper trail on', this.name);
+			}
+
+			this.rawAttributes[options.revisionAttribute] = {
+				type: Sequelize.INTEGER,
+				defaultValue: 0,
+			};
+			this.revisionable = true;
+
+			// not sure if we need this
+			this.refreshAttributes();
+
+			if (options.enableMigration) {
+				const tableName = this.getTableName();
+
+				const queryInterface = sequelize.getQueryInterface();
+
+				queryInterface.describeTable(tableName).then(attributes => {
+					if (!attributes[options.revisionAttribute]) {
+						if (options.debug) {
+							log('adding revision attribute to the database');
+						}
+
+						queryInterface
+							.addColumn(tableName, options.revisionAttribute, {
+								type: Sequelize.INTEGER,
+								defaultValue: 0,
+							})
+							.then(() => null)
+							.catch(err => {
+								log('something went really wrong..', err);
+								return null;
+							});
+					}
+					return null;
+				});
+			}
+
+			this.addHook('beforeCreate', createBeforeHook('create'));
+			this.addHook('beforeDestroy', createBeforeHook('destroy'));
+			this.addHook('beforeUpdate', createBeforeHook('update'));
+			this.addHook('afterCreate', createAfterHook('create'));
+			this.addHook('afterDestroy', createAfterHook('destroy'));
+			this.addHook('afterUpdate', createAfterHook('update'));
+
+			// create association
+			return this.hasMany(sequelize.models[options.revisionModel], {
+				foreignKey: options.defaultAttributes.documentId,
+				constraints: false,
+				scope: {
+					model: this.name,
+				},
+			});
+		},
+	});
+
+	return {
+		// TWS-1032 since ALS must be set after a .run()
+		//   invocation this CANNOT be set on init().  If you would
+		//   like to use ALS, set it after the first invocation of run()
+		setupALS: function(asyncLocalStorage) {
+			options.als = asyncLocalStorage;
+		},
+		alsEnabled: function() {
+			return (options.als === true)
+		},
+		defineModels: function defineModels(db) {
+			// Attributes for RevisionModel
+			let attributes = {
+				model: {
+					type: Sequelize.TEXT,
+					allowNull: false,
+				},
+				document: {
+					type: Sequelize.JSONB,
+					allowNull: false,
+				},
+				operation: Sequelize.STRING(7),
+			};
+
+			if (options.mysql) {
+				attributes.document.type = Sequelize.TEXT('MEDIUMTEXT');
+			}
+
+			attributes[options.defaultAttributes.documentId] = {
+				type: Sequelize.INTEGER,
+				allowNull: false,
+			};
+
+			attributes[options.revisionAttribute] = {
+				type: Sequelize.INTEGER,
+				allowNull: false,
+			};
+
+			attributes[options.userModelAttribute] = {
+				type: Sequelize.INTEGER,
+				allowNull: true
+			};
+
+			if (options.UUID) {
+				attributes.id = {
+					primaryKey: true,
+					type: Sequelize.UUID,
+					defaultValue: Sequelize.UUIDV4,
+				};
+				attributes[options.defaultAttributes.documentId].type =
+					Sequelize.UUID;
+
+					console.log("userModelatribute", options.userModelAttribute)
+				attributes[options.userModelAttribute].type = Sequelize.UUID;
+			}
+
+			if (options.debug) {
+				log('attributes', attributes);
+			}
+
+			// Revision model
+			const Revision = sequelize.define(
+				options.revisionModel,
+				attributes,
+				{
+					underscored: options.underscored,
+					tableName: options.tableName,
+				},
+			);
+			Revision.associate = function associate(models) {
+				if (options.debug) {
+					log('models', models);
+				}
+
+				Revision.belongsTo(
+					sequelize.model(options.userModel),
+					options.belongsToUserOptions,
+				);
+			};
+
+			if (options.enableRevisionChangeModel) {
+				// Attributes for RevisionChangeModel
+				attributes = {
+					path: {
+						type: Sequelize.TEXT,
+						allowNull: false,
+					},
+					document: {
+						type: Sequelize.JSONB,
+						allowNull: false,
+					},
+					diff: {
+						type: Sequelize.JSONB,
+						allowNull: false,
+					},
+				};
+
+				if (options.mysql) {
+					attributes.document.type = Sequelize.TEXT('MEDIUMTEXT');
+					attributes.diff.type = Sequelize.TEXT('MEDIUMTEXT');
+				}
+
+				if (options.UUID) {
+					attributes.id = {
+						primaryKey: true,
+						type: Sequelize.UUID,
+						defaultValue: Sequelize.UUIDV4,
+					};
+				}
+				// RevisionChange model
+				const RevisionChange = sequelize.define(
+					options.revisionChangeModel,
+					attributes,
+					{
+						underscored: options.underscored,
+					},
+				);
+
+				// Set associations
+				Revision.hasMany(RevisionChange, {
+					foreignKey: options.defaultAttributes.revisionId,
+					constraints: false,
+				});
+
+				// https://github.com/nielsgl/sequelize-paper-trail/issues/10
+				// RevisionChange.belongsTo(Revision, {
+				// 	foreignKey: options.defaultAttributes.revisionId,
+				// });
+				RevisionChange.belongsTo(Revision);
+
+				if (db) db[RevisionChange.name] = RevisionChange;
+			}
+
+			if (db) db[Revision.name] = Revision;
+
+			/*
+			 * We could extract this to a separate function so that having a
+			 * user model doesn't require different loading
+			 *
+			 * or perhaps we could omit this because we are creating the
+			 * association through the associate call above.
+			 */
+			if (options.userModel) {
+				Revision.belongsTo(
+					sequelize.model(options.userModel),
+					options.belongsToUserOptions,
+				);
+			}
+
+			return Revision;
+		},
+	};
+};
+
+/**
+ * Throw exceptions when the user identifier from ALS is not set or if the
+ * revisionAttribute was not loaded on the model.
+ */
+paperTrail.enableFailHard = () => {
+	failHard = true;
+};
+
+export default paperTrail;