@questwork/q-utilities 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+Copyright 2019 Questwork Consulting Limited
+
+This project is free software released under the MIT/X11 license:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/index.js

@@ -0,0 +1,3 @@
+// 'use strict'
+
+export * from './lib'

package/lib/authenticator/authenticator.js

@@ -0,0 +1,56 @@
+const axios = require('axios')
+const { ClientApp } = require('./clientApp')
+
+async function getAuthToken({ id, appSecret, name, service, authServerHost, authServerPath, authPath, additionalData }) {
+  try {
+    const clientApp = _initClientApp({ id, appSecret, name })
+    return _getAuthToken({
+      clientApp, service, authServerHost, authServerPath, authPath, additionalData
+    })
+  } catch (err) {
+    throw err
+  }
+}
+
+function _getAuthCredentials({ clientApp, service, additionalData }) {
+  const jwt = clientApp.getJwtToken()
+  const data = {
+    service,
+    ...additionalData
+  }
+  const headers = { Authorization: `Bearer ${jwt}` }
+  return {
+    data,
+    headers
+  }
+}
+
+async function _getAuthToken({ clientApp, service, authServerHost, authServerPath, authPath, additionalData }) {
+  try {
+    const path = authServerPath || authPath
+    if (!!path && !!authServerHost) {
+      const { data, headers } = _getAuthCredentials({ clientApp, service, additionalData })
+      const response = await axios.post(`${authServerHost}${path}`, data, { headers })
+      return response.data
+    }
+    throw new Error('missing auth server')
+  } catch (err) {
+    const message = err.response && err.response.data ? err.response.data.message : err.message
+    throw new Error(`failed to get ServiceApp token: ${message}`)
+  }
+}
+
+function _initClientApp({ id, appSecret, name } = {}) {
+  try {
+    const clientApp = ClientApp.init({
+      id, appSecret, name
+    })
+    return clientApp
+  } catch (err) {
+    throw new Error(`invalid ClientApp: ${err.message}`)
+  }
+}
+
+module.exports = {
+  getAuthToken
+}

package/lib/authenticator/clientApp.js

@@ -0,0 +1,46 @@
+const { jwtHelper } = require('../jwtHelper')
+
+const TOKEN_EXPIRY = 300
+
+class ClientApp {
+  constructor(options) {
+    options = options || {}
+    this.id = options.id
+    this.appSecret = options.appSecret
+    this.name = options.name
+  }
+
+  // Class method
+  static init(options = {}) {
+    const clientApp = new ClientApp(options)
+    return clientApp.isValid ? clientApp : null
+  }
+
+  // Getter
+  get isValid() {
+    return !!this.name && !!this.appSecret && !!this.id
+  }
+
+  // instance methods
+  getJwtPayload() {
+    return {
+      clientApp: {
+        id: this.id,
+        name: this.name
+      }
+    }
+  }
+  getJwtToken({ tokenExpiry } = {}) {
+    const iExpiry = tokenExpiry || Math.floor(Date.now() / 1000) + TOKEN_EXPIRY // must be second
+    return jwtHelper.create(
+      this.getJwtPayload(),
+      {
+        secret: this.appSecret,
+        expiry: iExpiry
+      })
+  }
+}
+
+module.exports = {
+  ClientApp
+}

package/lib/authenticator/index.js

@@ -0,0 +1,5 @@
+const authenticator = require('./authenticator')
+
+module.exports = {
+  authenticator
+}

package/lib/convertString/convertString.js

@@ -0,0 +1,20 @@
+function convertString(string, patternMatch = /\$\{(.+?)\}/g, value, getValueByKeys) {
+  if (!string || typeof getValueByKeys !== 'function') {
+    return ''
+  }
+  const reg = new RegExp(patternMatch, 'g')
+  return string.replace(reg, (match, key) => {
+    const result = getValueByKeys({ keys: key.split('.'), obj: value })
+    if (result === null || result === undefined) {
+      return ''
+    }
+    return typeof result === 'object' ? JSON.stringify(result) : result
+  })
+}
+
+export default {
+  convertString
+}
+export {
+  convertString
+}

package/lib/convertString/index.js

@@ -0,0 +1 @@
+export { convertString } from './convertString'

package/lib/cryptoHelper/cryptoHelper.js

@@ -0,0 +1,93 @@
+// const crypto = require('crypto-browserify')
+const crypto = require('crypto')
+// const { subtle } = globalThis.crypto
+
+const cryptoHelper = {
+  createHash(algorithm, options) {
+    return crypto.createHash(algorithm, options)
+  },
+
+  createHmac(algorithm, key, options) {
+    return crypto.createHmac(algorithm, key, options)
+  },
+
+  createSign(algorithm, options) {
+    return crypto.createSign(algorithm, options)
+  },
+
+  createVerify(algorithm, options) {
+    return crypto.createVerify(algorithm, options)
+  },
+
+  digest(instance, outputEncoding) {
+    if (!(typeof instance.digest === 'function')) {
+      throw new Error('no digest method')
+    }
+    return instance.digest(outputEncoding)
+  },
+
+  sign({ instance, privateKey, outputEncoding }) {
+    if (!(typeof instance.sign === 'function')) {
+      throw new Error('no sign method')
+    }
+    return instance.sign(privateKey, outputEncoding)
+  },
+
+  verify({ instance, object, signature, signatureEncoding }) {
+    if (!(typeof instance.verify === 'function')) {
+      throw new Error('no verify method')
+    }
+    return instance.verify(object, signature, signatureEncoding)
+  },
+
+  update({ instance, data, inputEncoding }) {
+    if (!(typeof instance.update === 'function')) {
+      throw new Error('no update method')
+    }
+    return instance.update(data, inputEncoding)
+  },
+
+  createStringHmac({ algorithm, options, key, data, inputEncoding, outputEncoding }) {
+    try {
+      const hmac = this.createHmac(algorithm, key, options)
+      const instance = this.update({ instance: hmac, data, inputEncoding })
+      return this.digest(instance, outputEncoding)
+    } catch (err) {
+      throw err
+    }
+  },
+
+  createStringVerify({ algorithm, options, data, object, signature, inputEncoding, signatureEncoding }) {
+    try {
+      const verify = this.createVerify(algorithm, options)
+      const instance = this.update({ instance: verify, data, inputEncoding })
+      return this.verify({ instance, object, signature, signatureEncoding })
+    } catch (err) {
+      throw err
+    }
+  },
+
+  createSignature({ algorithm, options, data, privateKey, inputEncoding, outputEncoding }) {
+    try {
+      const sign = this.createSign(algorithm, options)
+      const instance = this.update({ instance: sign, data, inputEncoding })
+      return this.sign({ instance, privateKey, outputEncoding })
+    } catch (err) {
+      throw err
+    }
+  },
+
+  createStringHash({ algorithm, options, data, inputEncoding, outputEncoding }) {
+    try {
+      const hash = this.createHash(algorithm, options)
+      const instance = this.update({ instance: hash, data, inputEncoding })
+      return this.digest(instance, outputEncoding)
+    } catch (err) {
+      throw err
+    }
+  }
+}
+
+module.exports = {
+  cryptoHelper
+}

package/lib/cryptoHelper/index.js

@@ -0,0 +1,5 @@
+const { cryptoHelper } = require('./cryptoHelper')
+
+module.exports = {
+  cryptoHelper
+}

package/lib/getValidation/getValidation.js

@@ -0,0 +1,117 @@
+function getValidation(rule, data, getDataByKey, KeyValueObject) {
+  if (!rule) {
+    return true
+  }
+  if (typeof getDataByKey !== 'function' || typeof KeyValueObject !== 'function') {
+    return false
+  }
+  const { key = '', value, keyValuePath = '' } = rule
+  const [valueAttribute] = Object.keys(value)
+
+  if (!key) {
+    switch (valueAttribute) {
+      case '$and': {
+        const arr = value['$and']
+        return arr.reduce((acc, item) => (acc && getValidation(item, data, getDataByKey)), true)
+      }
+      case '$or': {
+        const arr = value['$or']
+        return arr.reduce((acc, item) => (acc || getValidation(item, data, getDataByKey)), false)
+      }
+      default:
+        return false
+    }
+  }
+
+  let rowValue = getDataByKey(key, data)
+
+  // debugger
+
+  // if KeyValue object
+  if (keyValuePath) {
+    console.log('keyValuePath', keyValuePath)
+    const rowValueData = KeyValueObject.toObject(rowValue)
+    rowValue = getDataByKey(keyValuePath, rowValueData)
+  }
+
+  switch (valueAttribute) {
+    case '$empty': {
+      const isEmpty = rowValue === null || rowValue === undefined
+      return isEmpty === value['$empty']
+    }
+    case '$eq': {
+      return rowValue === value['$eq']
+    }
+    case '$gt': {
+      return rowValue > value['$gt']
+    }
+    case '$gte': {
+      return rowValue >= value['$gte']
+    }
+    case '$lt': {
+      return rowValue < value['$lt']
+    }
+    case '$lte': {
+      return rowValue <= value['$lte']
+    }
+    case '$in': {
+      if (Array.isArray(rowValue)) {
+        return !!rowValue.find((e) => (value['$in'].includes(e)))
+      }
+      if (typeof rowValue !== 'object') {
+        return !!value['$in'].includes(rowValue)
+      }
+      return false
+    }
+    case '$inValue': {
+      const result = getDataByKey(value['$inValue'], data)
+      const _value = Array.isArray(result) ? result : []
+      if (Array.isArray(rowValue)) {
+        return !!rowValue.find((e) => (_value.includes(e)))
+      }
+      if (typeof rowValue === 'string') {
+        return !!_value.includes(rowValue)
+      }
+      return false
+    }
+    case '$ne': {
+      return rowValue !== value['$ne']
+    }
+    case '$notIn': {
+      if (Array.isArray(rowValue)) {
+        return !rowValue.find((e) => (value['$notIn'].includes(e)))
+      }
+      if (typeof rowValue !== 'object') {
+        return !value['$notIn'].includes(rowValue)
+      }
+      return false
+    }
+    case '$notInValue': {
+      const result = getDataByKey(value['$notInValue'], data)
+      const _value = Array.isArray(result) ? result : []
+      if (Array.isArray(rowValue)) {
+        return !rowValue.find((e) => (_value.includes(e)))
+      }
+      if (typeof rowValue !== 'object') {
+        return !_value.includes(rowValue)
+      }
+      return false
+    }
+    case '$range': {
+      const [min, max] = value['$range']
+      if (typeof min === 'number' && typeof max === 'number' && rowValue >= min && rowValue <= max) {
+        return true
+      }
+      return false
+    }
+    default:
+      return false
+  }
+}
+
+export default {
+  getValidation
+}
+export {
+  getValidation
+}

package/lib/getValidation/index.js

@@ -0,0 +1 @@
+export { getValidation } from './getValidation'

package/lib/getValueByKeys/getValueByKeys.js

@@ -0,0 +1,20 @@
+function getValueByKeys(keys, data) {
+  if (keys.length === 0) {
+    return data
+  }
+  const firstKey = keys.shift()
+  if (data && Object.prototype.hasOwnProperty.call(data, firstKey)) {
+    return getValueByKeys(keys, data[firstKey])
+  }
+  if (data && firstKey) {
+    return data[firstKey]
+  }
+  return data
+}
+export default {
+  getValueByKeys
+}
+export {
+  getValueByKeys
+}
+

package/lib/getValueByKeys/index.js

@@ -0,0 +1 @@
+export { getValueByKeys } from './getValueByKeys'

package/lib/index.js

@@ -0,0 +1,14 @@
+// const { authenticator } = require('./authenticator')
+// const { cryptoHelper } = require('./cryptoHelper')
+// const { jwtHelper } = require('./jwtHelper')
+
+// module.exports = {
+//   authenticator,
+//   cryptoHelper,
+//   jwtHelper
+// }
+
+export * from './convertString'
+export * from './getValidation'
+export * from './getValueByKeys'
+export * from './keyValueObject'

package/lib/jwtHelper/index.js

@@ -0,0 +1,5 @@
+const { jwtHelper } = require('./jwtHelper')
+
+module.exports = {
+  jwtHelper
+}

package/lib/jwtHelper/jwtHelper.js

@@ -0,0 +1,254 @@
+// 'use strict'
+
+/* eslint-disable new-cap */
+/* eslint-disable camelcase */
+/* eslint-disable no-mixed-operators */
+/* eslint-disable no-useless-escape */
+/* eslint-disable no-param-reassign */
+
+/* eslint func-names: 0 */
+
+const Buffer = require('buffer/').Buffer
+
+const EXPIRY = 3600 // in second
+const ALGORITHM = 'HS256'
+const SECRET = 'ab1234cd'
+
+const jwtHelper = {
+  create(obj, { secret, algorithm, expiry } = {}) {
+    const sAlgorithm = algorithm || ALGORITHM
+    const sSecret = secret || SECRET
+    const exp = expiry || getTimeInSecond() + EXPIRY
+    const payload = {
+      ...obj,
+      exp
+    }
+    return encode(payload, sSecret, sAlgorithm)
+  },
+  createByUser(loginAccount) {
+    const exp = getTimeInSecond() + EXPIRY
+    const payload = {
+      loginAccount,
+      exp
+    }
+    return this.encode(payload)
+  },
+  encode(payload, algorithm) {
+    return encode(payload, SECRET, algorithm)
+  },
+  decode(token, algorithm) {
+    const noVerify = !this.verify(token)
+    return decode(token, SECRET, noVerify, algorithm) // if noVerify = true, may skip verification
+  },
+  getPayload(token) {
+    const payload = getPayload(token)
+    return {
+      payload
+    }
+  },
+  getPayloadIdByKey(token, key) {
+    const payload = getPayload(token)
+    const id = payload[key] ? payload[key].id : null
+    return {
+      id,
+      jwtToken: token
+    }
+  },
+  resolve(token, secret, algorithm) {
+    const sSecret = secret || SECRET
+    return decode(token, sSecret, false, algorithm) // need verification
+  },
+  verify(token) {
+    const payload = getPayload(token)
+    const today = getTimeInSecond()
+    return (payload.exp && (today <= payload.exp)) || false
+  }
+}
+
+/**
+ * Private functions
+ */
+
+const getPayload = (token) => decode(token, SECRET, true)
+
+const getTimeInSecond = () => Math.floor(Date.now() / 1000)
+
+/**
+ * Private functions, based on jwt-simple 0.2.0
+ */
+
+const { cryptoHelper } = require('../cryptoHelper')
+
+const algorithmMap = {
+  HS256: 'sha256',
+  HS384: 'sha384',
+  HS512: 'sha512',
+  RS256: 'RSA-SHA256'
+}
+
+const typeMap = {
+  HS256: 'hmac',
+  HS384: 'hmac',
+  HS512: 'hmac',
+  RS256: 'sign'
+}
+
+
+/**
+ * Decode jwt
+ *
+ * @param {Object} token
+ * @param {String} key
+ * @param {Boolean} noVerify
+ * @param {String} algorithm
+ * @return {Object} payload
+ * @api public
+ */
+const decode = function jwt_decode(token, key, noVerify, algorithm) {
+  // check token
+  if (!token) {
+    throw new Error('No token supplied')
+  }
+  // check segments
+  const segments = token.split('.')
+  if (segments.length !== 3) {
+    throw new Error('Not enough or too many segments')
+  }
+
+  // All segment should be base64
+  const headerSeg = segments[0]
+  const payloadSeg = segments[1]
+  const signatureSeg = segments[2]
+
+  // base64 decode and parse JSON
+  const header = JSON.parse(base64urlDecode(headerSeg))
+
+  const payload = JSON.parse(base64urlDecode(payloadSeg))
+
+  if (!noVerify) {
+    const signingMethod = algorithmMap[algorithm || header.alg]
+    const signingType = typeMap[algorithm || header.alg]
+    if (!signingMethod || !signingType) {
+      throw new Error('Algorithm not supported')
+    }
+
+    // verify signature. `sign` will return base64 string.
+    const signingInput = [headerSeg, payloadSeg].join('.')
+    if (!verify(signingInput, key, signingMethod, signingType, signatureSeg)) {
+      throw new Error('Signature verification failed')
+    }
+  }
+
+  return payload
+}
+
+
+/**
+ * Encode jwt
+ *
+ * @param {Object} payload
+ * @param {String} key
+ * @param {String} algorithm
+ * @return {String} token
+ * @api public
+ */
+const encode = function jwt_encode(payload, key, algorithm) {
+  // Check key
+  if (!key) {
+    throw new Error('Require key')
+  }
+
+  // Check algorithm, default is HS256
+  if (!algorithm) {
+    algorithm = ALGORITHM
+  }
+
+  const signingMethod = algorithmMap[algorithm]
+  const signingType = typeMap[algorithm]
+  if (!signingMethod || !signingType) {
+    throw new Error('Algorithm not supported')
+  }
+
+  // header, typ is fixed value.
+  const header = { typ: 'JWT', alg: algorithm }
+
+  // create segments, all segments should be base64 string
+  const segments = []
+  segments.push(base64urlEncode(JSON.stringify(header)))
+  segments.push(base64urlEncode(JSON.stringify(payload)))
+  segments.push(sign(segments.join('.'), key, signingMethod, signingType))
+
+  return segments.join('.')
+}
+
+
+/**
+ * private util functions
+ */
+
+function verify(input, key, method, type, signature) {
+  if (type === 'hmac') {
+    return (signature === sign(input, key, method, type))
+  } else if (type === 'sign') {
+    try {
+      return cryptoHelper.createStringVerify({
+        algorithm: method,
+        data: input,
+        object: key,
+        signature: base64urlUnescape(signature),
+        signatureEncoding: 'base64'
+      })
+    } catch (error) {
+      throw new Error('createStringVerify failed')
+    }
+  }
+  throw new Error('Algorithm type not recognized')
+}
+
+function sign(input, key, method, type) {
+  let base64str
+  if (type === 'hmac') {
+    base64str = cryptoHelper.createStringHmac({
+      algorithm: method,
+      key,
+      data: input,
+      outputEncoding: 'base64'
+    })
+  } else if (type === 'sign') {
+    try {
+      base64str = cryptoHelper.createSignature({
+        algorithm: method,
+        data: input,
+        privateKey: key,
+        outputEncoding: 'base64'
+      })
+    } catch (error) {
+      throw new Error('createSignature failed')
+    }
+  } else {
+    throw new Error('Algorithm type not recognized')
+  }
+  return base64urlEscape(base64str)
+}
+
+function base64urlDecode(str) {
+  // fixed bug if decode string is incorrect
+  return (new Buffer.from(base64urlUnescape(str), 'base64')).toString() || '{}'
+}
+
+function base64urlUnescape(str) {
+  str += new Array(5 - str.length % 4).join('=')
+  return str.replace(/\-/g, '+').replace(/_/g, '/')
+}
+
+function base64urlEncode(str) {
+  return base64urlEscape(new Buffer.from((str)).toString('base64'))
+}
+
+function base64urlEscape(str) {
+  return str.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+}
+
+module.exports = {
+  jwtHelper
+}

package/lib/keyValueObject/index.js

@@ -0,0 +1 @@
+export { KeyValueObject } from './keyValueObject'

package/lib/keyValueObject/keyValueObject.js

@@ -0,0 +1,163 @@
+'use strict'
+
+class KeyValueObject {
+  constructor(options = {}) {
+    options = options || {}
+    this.key = options.key || null
+    this.value = (typeof options.value !== 'undefined') ? options.value : ''
+  }
+
+  // Class methods
+
+  static addItem(arr, key, value) {
+    arr.push(
+      { key, value }
+    )
+  }
+  static addRecord(arr = [], key, value) {
+    const self = this
+    if (!KeyValueObject.hasKeyValue(arr, key, value)) {
+      arr.push(self.init({ key, value }))
+    }
+    return arr
+  }
+
+  static fromObject(options = {}) {
+    const self = this
+    return Object.keys(options).reduce((acc, key) => {
+      acc.push(self.init({ key, value: options[key] }))
+      return acc
+    }, [])
+  }
+
+  static removeByKey(arr, key) {
+    return arr.reduce((acc, item) => {
+      if (item.key !== key) {
+        acc.push(item)
+      }
+      return acc
+    }, [])
+  }
+
+  static getValuesByKey(arr = [], key) {
+    return arr.reduce((acc, item) => {
+      if (item.key === key) {
+        acc.push(item.value)
+      }
+      return acc
+    }, [])
+  }
+
+  static hasKeyValue(arr = [], key, value) {
+    if (typeof value === 'undefined') {
+      return arr.filter((item) => item.key === key).length > 0
+    }
+    return arr.filter((item) => (item.key === key && item.value === value)).length > 0
+  }
+
+  static init(options = {}) {
+    if (options instanceof KeyValueObject) {
+      return options
+    }
+    const kvObject = new KeyValueObject(options)
+    return kvObject.isValid ? kvObject : null
+  }
+
+  static initFromArray(arr = []) {
+    const self = this
+    if (Array.isArray(arr)) {
+      return arr.map(self.init)
+    }
+    return []
+  }
+
+  static initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+
+  static keys(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc.push(item.key)
+        return acc
+      }, [])
+    }
+    return []
+  }
+
+  static toObject(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc[item.key] = item.value
+        return acc
+      }, {})
+    }
+    return {}
+  }
+
+  static toString(arr = [], delimiter = '; ') {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc.push(`${item.key}: ${item.value}`)
+        return acc
+      }, []).join(delimiter)
+    }
+    return ''
+  }
+
+  static updateRecord(arr = [], key, value) {
+    return arr.map((item) => {
+      if (item.key === key) {
+        item.value = value
+      }
+      return item
+    })
+  }
+
+  static updateOrInsertRecord(arr = [], key, value) {
+    const self = this
+    let copy = [...arr]
+    if (!self.hasKeyValue(arr, key)) {
+      copy.push(self.init({ key, value }))
+    } else {
+      copy = self.updateRecord(arr, key, value)
+    }
+    return copy
+  }
+
+  static updateRecordsFromArray(arr = [], updateArr = []) {
+    if (Array.isArray(arr) && Array.isArray(updateArr)) {
+      const obj1 = KeyValueObject.toObject(arr)
+      const obj2 = KeyValueObject.toObject(updateArr)
+      return KeyValueObject.fromObject(Object.assign({}, obj1, obj2))
+    }
+    return []
+  }
+
+  static values(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc.push(item.value)
+        return acc
+      }, [])
+    }
+    return []
+  }
+
+  // getters
+  get isValid() {
+    return !!this.key
+  }
+
+  get toObject() {
+    const obj = {}
+    if (this.isValid) {
+      obj[this.key] = this.value
+    }
+    return obj
+  }
+}
+
+export {
+  KeyValueObject
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@questwork/q-utilities",
+  "version": "0.1.0",
+  "description": "Questwork QUtilities",
+  "main": "index.js",
+  "author": {
+    "name": "Questwork Consulting Limited",
+    "email": "info@questwork.com",
+    "url": "https://questwork.com/"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^0.28.1",
+    "buffer": "^6.0.3"
+  },
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "eslint": "4.0.0",
+    "eslint-config-airbnb-base": "11.2.0",
+    "eslint-plugin-import": "2.3.0",
+    "eslint-plugin-mocha": "^5.3.0",
+    "mocha": "^6.2.2",
+    "nodemon": "^2.0.2"
+  },
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "test": "mocha --exit 'test/test.setup.js' 'test/**/*.spec.js'",
+    "test-models": "NODE_ENV=test mocha --exit 'test/test.setup.js' 'test/**/*.spec.js'"
+  }
+}