@sera4/essentia 1.1.65 → 3.0.6

package/helpers/test-server-wrapper.js

@@ -1,196 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import fs from "fs";
-
-const s4Domain = "sera4.com";
-const mobileDomain = "tws-mob." + s4Domain;
-const webDomain = "tws-web." + s4Domain;
-
-/**
- * A small wrapper around an express js server
- * meant to be used in unit tests
- */
-export class TestServerWrapper {
-
-  constructor(apiPrefix, expressServer, defaultHeaders, oldAuthToken, routePrinter, chai, factory) {
-    this.server = expressServer;
-    this.defaultHeaders = defaultHeaders;
-    this.apiPrefix = apiPrefix;
-    this.routePrinter = routePrinter;
-    this.chai = chai;
-    this.mobileDomain = mobileDomain;
-    this.webDomain = webDomain;
-    this.factory = factory;
-
-    // Support for older/deprecated apis
-    const oldAuthHeaders = {headers: {"Authorization" : `Token organization_token=${oldAuthToken}`}};
-    this.v1 = {
-      get: (url) => this.getWithPrefix("/v1", url, oldAuthHeaders),
-      post: (url) => this.postWithPrefix("/v1", url, oldAuthHeaders),
-      put: (url) => this.putWithPrefix("/v1", url, oldAuthHeaders),
-      delete: (url) => this.deleteWithPrefix("/v1", url, oldAuthHeaders)
-    }
-  }
-
-  /**
-   * Adds a leading slash to the url if missing
-   * @param {String} url the url to sanitize
-   * @returns sanitized url
-   */
-  sanitizeUrl (url) {
-    // add leading slash if missing
-    if (!url.startsWith("/")) {
-      return "/" + url;
-    } else {
-      return url;
-    }
-  }
-
-  /**
-   * Apply given headers to the request object
-   * @param {Object} request
-   * @param {Object} headers
-   */
-  applyHeaders (request, headers) {
-    Object.keys(headers).map(k => {
-      request.set(k, headers[k]);
-    });
-  }
-
-  get (url, options) {
-    return this.getWithPrefix(this.apiPrefix, url, options);
-  }
-
-  getWithPrefix (prefix, url, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).get(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    if (options?.body) {
-      request.send(options.body);
-    }
-    return request;
-  }
-
-  post (url, options) {
-    return this.postWithPrefix(this.apiPrefix, url, options);
-  }
-
-  postWithPrefix (prefix, url, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).post(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    return request;
-  }
-
-  put (url, options) {
-    return this.putWithPrefix(this.apiPrefix, url, options);
-  }
-
-  putWithPrefix (prefix, url, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).put(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    return request;
-  }
-
-  delete (url, options) {
-    return this.deleteWithPrefix(this.apiPrefix, url, options);
-  }
-
-  deleteWithPrefix (prefix, url, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).delete(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    return request;
-  }
-
-  upload ( url, fields, file, options) {
-    return this.uploadWithPrefix(this.apiPrefix, url, fields, file, options);
-  }
-
-  uploadWithPrefix (prefix, url, fields, file, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).post(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    request.attach("data", fs.readFileSync(file), {filename: "data"});
-    const keys = Object.keys(fields);
-    keys.forEach(k => {
-      request.field(k, fields[k]);
-    });
-    return request;
-  }
-
-  stop () {
-    this.server.close();
-  }
-
-  allRoutes () {
-    return this.routePrinter.getAll();
-  }
-
-  withHeaders (headers) {
-    return {
-      get: (url, options) => this.get(url, {headers, ...options}),
-      post: (url, options) => this.post(url, {headers, ...options}),
-      put: (url, options) => this.put(url, {headers, ...options}),
-      delete: (url, options) => this.delete(url, {headers, ...options}),
-      upload: (url, fields, file, options) => this.upload(url, fields, file, {headers, ...options}),
-      stop: this.stop,
-      allRoutes: this.allRoutes,
-      v1: this.v1
-    }
-  }
-
-  // setup
-  async setMembership (membership, addlHeaders) {
-    let headers;
-
-    if (membership) {
-      headers = { "tws-account-id" : membership.account_id, "tws-membership-id": membership.id, "tws-tenant-id" : membership.tenant_id };
-    } else {
-      // auto create an s4 user
-      const m = await this.factory.create("membership", { s4Admin: true })
-      headers = { "tws-account-id" : m.account_id, "tws-membership-id": m.id, "tws-tenant-id" : m.tenant_id };
-    }
-
-    headers = { ...headers, "tws-request-host": this.webDomain, ...addlHeaders }
-    return this.withHeaders(headers);
-  };
-
-  withMembership (m) {
-    const h = { "tws-membership" : JSON.stringify(m) }
-    return this.withHeaders(h);
-  }
-
-  withS4 () {
-    return this.withMembership({s4_role: 1, id: uuidv4(), account_id: uuidv4(), tenant_id: uuidv4()});
-  }
-
-  withTap() {
-    return this.withMembership({s4_role: 2, id: uuidv4(), account_id: uuidv4(), tenant_id: uuidv4()});
-  }
-}

package/last-commit.js

@@ -1,12 +0,0 @@
-"use strict";
-import lastCommit from "./last_commit/index.js"
-
-lastCommit.writeLastCommit()
-.then(c => {
-  console.debug("Last commit written");
-  console.debug(c);
-})
-.catch(e => {
-  console.error("Failed to write last commit");
-  console.error(e);
-})

package/last_commit/index.js

@@ -1,82 +0,0 @@
-"use strict";
-
-import git from "git-rev";
-import fs from "fs";
-import async from "async";
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const appDir = dirname(fileURLToPath(import.meta.url));
-const commitFile = `${appDir}/last-commit.json`;
-
-const lastCommit = {
-  parseLastCommit() {
-    return new Promise((resolve, reject) => {
-      async.waterfall([
-        (next) => {
-          var commit = {};
-          git.branch((str) => {
-            commit["branch"] = str;
-            next(null, commit);
-          });
-        },
-        (commit, next) => {
-          git.long((str) => {
-            commit["commmit"] = str;
-            next(null, commit);
-          });
-        }
-      ], (err, commit) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(commit);
-        }
-      })
-    })
-  },
-  getLastCommit() {
-    return new Promise((resolve, reject) => {
-      fs.readFile(commitFile, 'utf8', (err, data) => {
-        if (err) {
-          reject(err);
-        } else {
-          try {
-            var commit = JSON.parse(data);
-            resolve(commit);
-          } catch (e) {
-            reject(e);
-          }
-        }
-      });
-    });
-  },
-  getLastCommitSync() {
-    var data = fs.readFileSync(commitFile, 'utf8');
-    return JSON.parse(data);
-  },
-  writeLastCommit() {
-    return new Promise((resolve, reject) => {
-      async.waterfall([
-        (next) => {
-          this.parseLastCommit()
-          .then((commit) => next(null, commit))
-          .catch(e => next(e));
-        },
-        (commit, next) => {
-          fs.writeFile(commitFile, JSON.stringify(commit, null, 2), 'utf8', (err) => {
-            next(err, commit);
-          });
-        }
-      ],(err, commit) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(commit);
-        }
-      })
-    });
-  }
-}
-
-export default lastCommit;

package/logger/s4-logger.js

@@ -1,128 +0,0 @@
-import winston from "winston";
-import util from "util";
-import jsonStringify from "fast-safe-stringify";
-const colorizer = winston.format.colorize();
-import "winston-logstash";
-
-// IETF RFC5424:
-// Severity of all levels is assumed to be numerically ascending from most important to least important.
-const levels = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-  trace: 4,
-};
-
-// These colors are not used, however if colors are not defined for custom levels
-// then winston will throw an exception.
-winston.addColors({
-  trace: 'white'
-});
-
-const defaultLevel = process.env.NODE_ENV === 'production' ? 'info' : 'debug';
-
-// These colors are not used, however if colors are not defined for custom levels
-// then winston will throw an exception.
-winston.addColors({
-  trace: 'white'
-});
-
-const devFormat = {
-  transform(info) {
-    const { message } = info;
-    const level = info[Symbol.for('level')];
-    const args = info[Symbol.for('splat')];
-    const strArgs = args ? args.map(jsonStringify).join(' ') : "";
-    info[Symbol.for('message')] = colorizer.colorize(level, `${level}:\t`) + `${message} ${strArgs}`;
-    return info;
-  }
-};
-
-const defaultTransport = new winston.transports.Console({
-  format: devFormat,
-  level: 'trace'
-});
-
-const logger = winston.createLogger({
-  levels: levels,
-  level: defaultLevel,
-  defaultMeta: { },
-  transports: [defaultTransport]
-});
-
-class S4Logger {
-  configure(options) {
-    if (!options) {
-      return;
-    }
-
-    this.setLevel(options.level);
-
-    logger.defaultMeta.service = options.service;
-    switch(options.format.toLowerCase()) {
-      case "logstash":
-        defaultTransport.format = winston.format.logstash();
-        break;
-      case "json":
-        defaultTransport.format = winston.format.json();
-        break;
-      default:
-        defaultTransport.format = devFormat;
-        break;
-    }
-  }
-
-  setLevel(level) {
-    if (level && ["trace", "debug", "info", "error", "warn"].indexOf(level.toLowerCase())) {
-      logger.level = level;
-    }
-  }
-
-  mute() {
-    logger.transports.forEach(t => {
-      t.silent = true;
-    });
-  }
-
-  unmute() {
-    logger.transports.forEach(t => {
-      t.silent = false;
-    });
-  }
-
-  trace(...args) {
-    logger.trace(util.format(...args));
-  }
-
-  debug(...args) {
-    logger.debug(util.format(...args));
-  }
-
-  log(...args) {
-    logger.debug(util.format(...args));
-  }
-
-  warn(...args) {
-    logger.warn(util.format(...args));
-  }
-
-  info(...args) {
-    logger.info(util.format(...args));
-  }
-
-  error(...args) {
-    logger.error(util.format(...args));
-  }
-
-  getStream() {
-    return {
-      write: function(message, encoding){
-        logger.info(message);
-      }
-    }
-  }
-}
-
-const s4logger = new S4Logger();
-export default s4logger;

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;