@sera4/essentia 1.1.66-rc.1 → 3.0.8

package/paginator/README.md

@@ -1,183 +0,0 @@
-# PAGINATOR
-
-This is a module to add pagination to Sequelize ORM based projects.
-
-## Usage
-
-In your model definition, set pagination on your model
-
-```
-import { paginator } from "@sera4/essentia";
-...
-
-module.exports = (sequelize, DataTypes) => {
-  const Post = sequelize.define('Post', {...}, {...});
-  // Add pagination
-  paginator.paginate(Post);
-  return Post;
-};
-```
-
-Later in your controller you can call the paginate method on your model
-to return paginated results:
-
-```
-app.get('/posts', (req, res) => {
-  Post.using(req.query).paginate()
-  .then(p => res.status(200).json(p));
-})
-```
-
-For example, calling `/posts?page_size=2&page_index=1 will return
-something similar to the following:
-
-```
-{
-    "_pagination": {
-        "current_page": 1,
-        "first_page": false,
-        "last_page": false,
-        "page_size": 2,
-        "total_pages": 2500,
-        "total_size": 5000,
-        "out_of_bounds": false,
-        "previous_page": 0,
-        "next_page": 2
-    },
-    "_collection": [
-        {
-            "id": 42803,
-            "title": "FYrlujXyrcviLIkQNQsyIXEaRdARCJqNPIDsDiFuLxENtFXPRS",
-            "name": "uLHnWSekmNNKueYiglAkAwWckFetoSnudXalelnAkpnayIgiUi",
-            "content": "THISkjbnGVprKVFsMnlNEhgDYSGRZcomhNkcrbnuvnqogCdUen",
-            "created_at": "2018-11-03T16:04:10.526Z",
-            "updated_at": "2018-11-03T16:04:10.526Z"
-        },
-        {
-            "id": 42804,
-            "title": "VHgYIBGIuyObzHjrpAwFwbtZSVMnCZdTIAIzzlQHChEPbwGwmU",
-            "name": "upvMbeIKAcuwHBruLyPcwEUYlAbQqqljUcMajOyvGaqCTahwfs",
-            "content": "EeopiRHsUdNNqzshkafYqkVzACOyWQpdPXCBSzuPBIDHWGqWuk",
-            "created_at": "2018-11-03T16:04:10.534Z",
-            "updated_at": "2018-11-03T16:04:10.534Z"
-        }
-    ]
-}
-```
-
-The `using` method takes 2 parameters:
-
-* options - this is where the pagination parameters are read from. By default the method will be looking for `page_size` and `page_index`
-* res - this is the express js response object and the method will also add pagination in the headers (if configured as such)
-
-You can configure the pagination globally via `paginator.configure(options)`. The following options are available:
-
-* Configuring the url keys for pagination:
-  * `paginateIn.size=page_size` - This is the key that will be used to parse number of items to read when the `using` method is called. Renaming this to `per_page` for examle, the url must contain the following query parameters `/posts?per_page=20` to load 20 posts
-  * `paginateIn.index=page_index` - This is the key that will be used to parse the offset to read when the `using` method is called. Renaming this to `page` requires an url with `/posts?page_size=20&page=2` to read rows 21 through 40 from the database.
-* Configure the way the pagination data is displayed
-  * `paginateOut.current_page=current_page` Label used to show the current page value in the pagination data
-  * `paginateOut.first_page=first_page` Label used to show the first page value in the pagination data
-  * `paginateOut.last_page=last_page` Label used to show the last page value in the pagination data
-  * `paginateOut.next_page=next_page` Label used to show the next page value in the pagination data
-  * `paginateOut.out_of_bounds=out_of_bounds` Label used to show the out of bounds value in the pagination data
-  * `paginateOut.page_size=page_size` Label used to show the page size value in the pagination data
-  * `paginateOut.previous_page=previous_page` Label used to show the previous size value in the pagination data
-  * `paginateOut.total_pages=total_pages` Label used to show the total pages value in the pagination data
-  * `paginateOut.total_size=total_size` Label used to show the total size value in the pagination data
-  * `paginateOut.links=""` Label used to show the links in the pagination data. If this value is empty or null, no links are added in the pagination data. If set to `true`, then a `_links` key is added to the pagination data with links to previous and next pages if available. You can provide a non empty string instead of `true` to use your own lable for this key.
-* Other configurations:
-  * `zeroBasedOffset=true` When false, the indexing is done from 1, otherwise it's done from 0 like in arrays
-  * `paginationHeader=tws-pagination` The name of the pagination header used when adding pagination in the headers
-  * `headersOnly=false` If this is set to true, then the pagination will return an array of objects and all the pagination data can be found in the headers. Otherwise the result will have a key for pagination (`_pagination`) and a key for the results (`_collection`)
-  * `paginationTag=_pagination` Used to overwrite the key name used for pagination
-  * `collectionTag=_collection` Used to overwrite the key name used for results
-
-The configuration is done globally, so you can add something like this as early as possible to your code:
-
-```
-paginator.configure({
-  paginateIn : {
-    size: "items_per_page",
-    index: "page_number",
-  },
-  paginateOut : {
-    links: "myLinks",
-    current_page: "the_current_page"
-  },
-  zeroBasedOffset : false,
-  paginationTag : "paginationData",
-  collectionTag : "paginatedCollection"
-});
-```
-
-This will require an url like `/posts?items_per_page=2&page_number=1` and will produce the following results:
-
-```
-{
-    "paginationData": {
-        "the_current_page": 1,
-        "first_page": true,
-        "last_page": false,
-        "page_size": 2,
-        "total_pages": 2500,
-        "total_size": 5000,
-        "out_of_bounds": false,
-        "next_page": 2,
-        "myLinks": {
-            "first_page": "?page_number=1&items_per_page=2",
-            "last_page": "?page_number=2500&items_per_page=2",
-            "next_page": "?page_number=2&items_per_page=2"
-        }
-    },
-    "paginatedCollection": [
-        {
-            "id": 42801,
-            "title": "LJitZgbNPLpOlnkYdynKlSYnCjuLBYiVHYMfAPlSALeoVTuNKw",
-            "name": "cvnititqxdPnHdomgxJJVGynNInkScmDlkzAALunYFHNRjffqE",
-            "content": "LcURropLnJiudElgAVhsBSMRBRNUzHLDiTebZxxpplXdpeGEFa",
-            "created_at": "2018-11-03T16:04:10.511Z",
-            "updated_at": "2018-11-03T16:04:10.511Z"
-        },
-        {
-            "id": 42802,
-            "title": "mTyXHFoJjgXmwASYvfFgZJcstUTbHjvrcuVoaUMdXZmXuMrfBz",
-            "name": "yxrOfMUdiJqNMNdWAfKXbsMsskKbpeRzxfEoicEcSdNDhGaPBE",
-            "content": "TEAEugRIeOfceEyREmAGcxldDbtzqlaWGDRMIjAhmfAuwJraot",
-            "created_at": "2018-11-03T16:04:10.518Z",
-            "updated_at": "2018-11-03T16:04:10.518Z"
-        }
-    ]
-}
-```
-
-You may notice that the links in the pagination only have query parameters. If you want to include the resource, provide the resource name when adding pagination to your model.
-
-For example:
-```
-import { paginator } from "@sera4/essentia"
-...
-
-module.exports = (sequelize, DataTypes) => {
-  const Post = sequelize.define('Post', {...}, {...});
-  // Add pagination
-  paginator.paginate(Post, "/posts");
-  return Post;
-};
-```
-This will return pagination links in the pagination data prependend with the provided resource:
-```
-"myLinks": {
-    "first_page": "?page_number=1&items_per_page=2",
-    "last_page": "?page_number=2500&items_per_page=2",
-    "next_page": "?page_number=2&items_per_page=2"
-}
-```
-becomes
-```
-"myLinks": {
-    "first_page": "/posts?page_number=1&items_per_page=2",
-    "last_page": "/posts?page_number=2500&items_per_page=2",
-    "next_page": "/posts?page_number=2&items_per_page=2"
-}
-```

package/paginator/s4-pagination.js

@@ -1,51 +0,0 @@
-const default_page = 1;
-const default_size = 5;
-
-function parseRequest(req, item, default_value) {
-  if (!req || !req.query) {
-    return default_value;
-  }
-  var r = parseInt(req.query[item]);
-  if (isNaN(r) || r < default_value) {
-    r = default_value;
-  }
-  return r;
-}
-
-class S4Pagination {
-  createPaginator(req, res, next) {
-    var paginator = {
-      page : parseRequest(req, "page", default_page),
-      page_size : parseRequest(req, "page_size", default_size),
-      reply : function(data) {
-        if (!data) {
-          res.status(500).end();
-          return;
-        }
-        var pagination = {
-          total : data.total,
-          total_pages : data.pages,
-          current_page : data.page,
-          first_page : data.page === 1,
-          last_page : data.offset === data.pages,
-          page_size : data.limit,
-          out_of_bounds : data.docs.length === 0
-        }
-        if (!pagination.out_of_bounds) {
-          if (pagination.current_page > 1) {
-            pagination.previous_page = pagination.current_page - 1;
-          }
-          if (pagination.current_page < pagination.total_pages) {
-            pagination.next_page = pagination.current_page + 1;
-          }
-        }
-        res.set("s4-pagination", JSON.stringify(pagination));
-        res.json(data.docs)
-      }
-    }
-    return paginator;
-  }
-}
-
-const paginator = new S4Pagination();
-export default paginator;

package/paginator/sql-pagination.js

@@ -1,178 +0,0 @@
-"use strict"
-
-class SequelizePaginator {
-
-  constructor() {
-    this.paginateIn = {
-      size: "page_size",
-      index: "page_index"
-    };
-    this.paginateOut = {
-      current_page: "current_page",
-      first_page: "first_page",
-      last_page: "last_page",
-      next_page: "next_page",
-      out_of_bounds: "out_of_bounds",
-      page_size: "page_size",
-      previous_page: "previous_page",
-      total_pages: "total_pages",
-      total_size: "total_size",
-      links: "",
-    };
-    this.zeroBasedOffset = true;
-    this.paginationHeader = "tws-pagination";
-    this.headersOnly = false;
-    this.paginationTag = "_pagination";
-    this.collectionTag = "_collection";
-  }
-
-  paginate(Model, resource="") {
-    const model = Model.instance || Model;
-    const DEFAULT_PAGINATION = {limit : 15, offset: 0}
-    var pagination = {limit : 15, offset: 0}
-    var response = null;
-    var resource = resource;
-
-    const using = (options, resp) => {
-      response = resp;
-      var limit = DEFAULT_PAGINATION.limit;
-      var offset = DEFAULT_PAGINATION.offset;
-
-      if (options && options[this.paginateIn.size]) {
-        limit = parseInt(options[this.paginateIn.size]);
-      }
-      if (options && options[this.paginateIn.index]) {
-        offset = parseInt(options[this.paginateIn.index]);
-      }
-      if (!Number.isInteger(limit) || limit < 1) {
-        limit = 1;
-      }
-      if (!Number.isInteger(offset) || offset < 0) {
-        offset = 0;
-      }
-      if (!this.zeroBasedOffset) {
-        offset = offset <= 1 ? 0 : offset - 1;
-      }
-
-      pagination.limit = limit;
-      pagination.offset = offset;
-      return model;
-    }
-
-    const paginate = (options) => {
-      if (!options) {
-        options = {};
-      }
-      options.limit = pagination.limit;
-      options.offset = pagination.limit * pagination.offset;
-
-      return new Promise((resolve, reject) => {
-        model.findAndCountAll(options)
-        .then(r => {
-          var paginationData = getPaginationData(r);
-          if (response) {
-            response.set(this.paginationHeader, JSON.stringify(paginationData));
-          }
-          var data = {};
-          if (this.headersOnly) {
-            data = r.rows
-          } else {
-            data[this.paginationTag] = addLinks(paginationData);
-            data[this.collectionTag] = r.rows;
-          }
-          resolve(data);
-        }).catch(e => reject(e));
-      });
-    }
-
-    const addLinks = (data) => {
-      var linksKey = null;
-      if (this.paginateOut.links === true) {
-        linksKey = "links"
-      } else if (this.paginateOut.links) {
-        linksKey = this.paginateOut.links;
-      }
-      if (data && linksKey && !data[this.paginateOut["out_of_bounds"]]) {
-        var links = {}
-        var firstPageIndex = this.zeroBasedOffset ? 0 : 1;
-        var lastPageIndex = this.zeroBasedOffset ? data[this.paginateOut["total_pages"]] - 1 : data[this.paginateOut["total_pages"]];
-        links[this.paginateOut["first_page"]] = `${resource}?${this.paginateIn["index"]}=${firstPageIndex}&${this.paginateIn["size"]}=${data[this.paginateOut["page_size"]]}`;
-        links[this.paginateOut["last_page"]] = `${resource}?${this.paginateIn["index"]}=${lastPageIndex}&${this.paginateIn["size"]}=${data[this.paginateOut["page_size"]]}`;
-        if (!data[this.paginateOut["first_page"]]) {
-          links[this.paginateOut["previous_page"]] =
-          `${resource}?${this.paginateIn["index"]}=${data[this.paginateOut["previous_page"]]}&${this.paginateIn["size"]}=${data[this.paginateOut["page_size"]]}`;
-        }
-        if (!data[this.paginateOut["last_page"]]) {
-          links[this.paginateOut["next_page"]] =
-          `${resource}?${this.paginateIn["index"]}=${data[this.paginateOut["next_page"]]}&${this.paginateIn["size"]}=${data[this.paginateOut["page_size"]]}`;
-        }
-        data[linksKey] = links;
-      }
-      return data;
-    }
-
-    const getPaginationData = (result) => {
-      var currentPage = this.zeroBasedOffset ? pagination.offset : pagination.offset + 1;
-      var outOfBounds = result.rows.length === 0;
-
-      // For queries with aggregation (Group By, Count), sequelize findAndCountAll returns an array of objects instead of just an integer
-      // To avoid implementing a custom findAndCountAll, we just use the array's Length
-      if (Array.isArray(result.count)) {
-        result.count = result.count.length;
-      }
-
-      var totalPages = Math.ceil(result.count / pagination.limit);
-      var data = {};
-      data[this.paginateOut["current_page"]] = currentPage;
-      data[this.paginateOut["first_page"]] = outOfBounds ? false : pagination.offset === 0;
-      data[this.paginateOut["last_page"]] = outOfBounds ? false : (pagination.offset * pagination.limit) + pagination.limit >= result.count;
-      data[this.paginateOut["page_size"]] = pagination.limit;
-      data[this.paginateOut["total_pages"]] = totalPages;
-      data[this.paginateOut["total_size"]] = result.count;
-      data[this.paginateOut["out_of_bounds"]] = outOfBounds;
-      if (!outOfBounds) {
-        if ((this.zeroBasedOffset && currentPage > 0) || (!this.zeroBasedOffset && currentPage > 1)) {
-          data[this.paginateOut["previous_page"]] = currentPage - 1;
-        }
-        if ((this.zeroBasedOffset && currentPage + 1 < totalPages) || (!this.zeroBasedOffset && currentPage < totalPages)) {
-          data[this.paginateOut["next_page"]] = currentPage + 1;
-        }
-      }
-      return data;
-    }
-
-    model.using = using;
-    model.paginate = paginate;
-  }
-
-  configure(options) {
-    // Parse the object options
-    if (options.paginateIn) {
-      var x = options.paginateIn;
-      for (var key in this.paginateIn) {
-        if (this.paginateIn.hasOwnProperty(key) && x.hasOwnProperty(key)) {
-          this.paginateIn[key] = x[key];
-        }
-      }
-    }
-    if (options.paginateOut) {
-      var x = options.paginateOut;
-      for (var key in this.paginateOut) {
-        if (this.paginateOut.hasOwnProperty(key) && x.hasOwnProperty(key)) {
-          this.paginateOut[key] = x[key];
-        }
-      }
-    }
-    // Parse the simple options
-    for(var key in this) {
-      if (!["paginateIn", "paginateOut"].includes(key)) {
-        if (this.hasOwnProperty(key) && options.hasOwnProperty(key)) {
-          this[key] = options[key];
-        }
-      }
-    }
-  }
-}
-
-const sqlPaginator = new SequelizePaginator();
-export default sqlPaginator;

package/paper-trail/README.md

@@ -1,68 +0,0 @@
-# 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 });
-
-// sending in DB will allow you to access this using db['Revision'] later.
-db.PaperTrail.defineModels(db);
-
-.. 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

@@ -1,99 +0,0 @@
-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
-};