@questwork/q-utilities 0.1.2 → 0.1.4

package/dist/index.min.cjs

@@ -52,13 +52,13 @@ __webpack_require__.d(__webpack_exports__, {
   ApiResponse: () => (/* reexport */ ApiResponse),
   KeyValueObject: () => (/* reexport */ KeyValueObject),
   Metadata: () => (/* reexport */ Metadata),
+  QMeta: () => (/* reexport */ QMeta),
   Repo: () => (/* reexport */ Repo),
   Service: () => (/* reexport */ Service),
   convertString: () => (/* reexport */ convertString),
   formatDate: () => (/* reexport */ formatDate),
   getValidation: () => (/* reexport */ getValidation),
   getValueByKeys: () => (/* reexport */ getValueByKeys),
-  jwtHelper: () => (/* reexport */ jwtHelper),
   makeApiResponse: () => (/* reexport */ makeApiResponse),
   makeService: () => (/* reexport */ makeService),
   padZeros: () => (/* reexport */ padZeros),
@@ -289,284 +289,6 @@ function getValueByKeys(keys, data) {
 ;// ./lib/helpers/getValueByKeys/index.js
 
 
-;// ./lib/helpers/jwtHelper/jwtHelper.js
-// '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 _hasBuffer = typeof Buffer === 'function'
-
-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 _decode(str) {
-  if (_hasBuffer) {
-    return Buffer.from(base64urlUnescape(str), 'base64').toString('utf8')
-  }
-  return atob(base64urlUnescape(str))
-}
-
-function _encode(str) {
-  if (_hasBuffer) {
-    return base64urlEscape(Buffer.from(str, 'utf8').toString('base64'))
-  }
-  return base64urlEscape(btoa(str))
-}
-
-function base64urlDecode(str) {
-  // fixed bug if decode string is incorrect
-  // return (new Buffer.from(base64urlUnescape(str), 'base64')).toString() || '{}'
-  return _decode(str)
-}
-
-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'))
-  return _encode(str)
-}
-
-function base64urlEscape(str) {
-  return str.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
-}
-
-
-
-;// ./lib/helpers/jwtHelper/index.js
-
-
-
-
-
 ;// ./lib/helpers/padZeros/padZeros.js
 function padZeros(num, minLength = 6) {
   num = num.toString()
@@ -603,7 +325,6 @@ function stringFormatter(str) {
 
 
 
-
 ;// ./lib/models/apiResponse/apiResponse.js
 class ApiResponse {
   constructor(options = {}) {
@@ -694,107 +415,85 @@ class KeyValueObject {
   }
 
   static addItem(arr, key, value) {
-    arr.push(
-      { key, value }
-    )
+    arr.push(this.init({ key, value }))
   }
   static addRecord(arr = [], key, value) {
-    const self = this
     if (!this.hasKeyValue(arr, key, value)) {
-      arr.push(self.init({ key, value }))
+      arr.push(this.init({ key, value }))
     }
     return arr
   }
-
   static appendRecord(arr = [], key, value) {
     return arr.map((item) => {
-      if (item.key === key) {
+      if (this.sameKey(item, key)) {
         item.value = [...item.value, ...value]
       }
       return item
     })
   }
-
-  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)
+  static appendValueArray(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
       }
-      return acc
-    }, [])
+      return item
+    })
   }
-
   static foundByKey(arr = [], key) {
     const found = arr.find((m) => {
-      return m.key === key
+      return this.sameKey(m, key)
     })
     return found || null
   }
-
   static foundValueByKey(arr = [], key) {
     const found = this.foundByKey(arr, key)
     return found ? found.value : null
   }
-
+  static fromObject(options = {}) {
+    return Object.keys(options).reduce((acc, key) => {
+      acc.push(this.init({ key, value: options[key] }))
+      return acc
+    }, [])
+  }
   static getValueByKey(arr = [], key) {
-    const found = arr.find((i) => {
-      return i.key === key
-    })
-    if (found) {
-      return found.value
-    }
-    return null
+    return this.foundValueByKey(arr, key)
   }
-
   static getValueByKeyFromArray(arr = [], key) {
     if (arr.length === 0) {
       return null
     }
     const firstArr = arr.shift()
     const found = firstArr.find((i) => {
-      return i.key === key
+      return this.sameKey(i, key)
     })
     if (found && found.value) {
       return found.value
     }
     return this.getValueByKeyFromArray(arr, key)
   }
-
   static getValuesByKey(arr = [], key) {
     return arr.reduce((acc, item) => {
-      if (item.key === key) {
+      if (this.sameKey(item, 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) => this.sameKey(item, key)).length > 0
     }
-    return arr.filter((item) => (item.key === key && item.value === value)).length > 0
+    return arr.filter((item) => (this.sameKey(item, key) && item.value === value)).length > 0
   }
-
   static insertOrUpdateRecord(arr = [], key, value) {
-    const self = this
     let copy = [...arr]
-    if (!self.hasKeyValue(arr, key)) {
-      copy.push(self.init({ key, value }))
+    if (!this.hasKeyValue(arr, key)) {
+      copy.push(this.init({ key, value }))
     } else {
-      copy = self.updateRecord(arr, key, value)
+      copy = this.updateRecord(arr, key, value)
     }
     return copy
   }
-
   static keys(arr = []) {
     if (Array.isArray(arr)) {
       return arr.reduce((acc, item) => {
@@ -804,7 +503,6 @@ class KeyValueObject {
     }
     return []
   }
-
   static merge(toArr, fromArr) {
     (fromArr || []).map((from) => {
       const found = toArr.find((to) => {
@@ -818,7 +516,17 @@ class KeyValueObject {
     })
     return toArr
   }
-
+  static removeByKey(arr, key) {
+    return arr.reduce((acc, item) => {
+      if (!this.sameKey(item, key)) {
+        acc.push(item)
+      }
+      return acc
+    }, [])
+  }
+  static sameKey(item, key) {
+    return item.key === key
+  }
   static toObject(arr = []) {
     if (Array.isArray(arr)) {
       return arr.reduce((acc, item) => {
@@ -828,7 +536,6 @@ class KeyValueObject {
     }
     return {}
   }
-
   static toString(arr = [], delimiter = '; ') {
     if (Array.isArray(arr)) {
       return arr.reduce((acc, item) => {
@@ -838,10 +545,9 @@ class KeyValueObject {
     }
     return ''
   }
-
   static updateRecord(arr = [], key, value) {
     return arr.map((item) => {
-      if (item.key === key) {
+      if (this.sameKey(item, key)) {
         return {
           ...item,
           value
@@ -850,11 +556,9 @@ class KeyValueObject {
       return item
     })
   }
-
   static updateOrInsertRecord(arr = [], key, value) {
     return this.insertOrUpdateRecord(arr, key, value)
   }
-
   static updateRecordsFromArray(arr = [], updateArr = []) {
     if (Array.isArray(arr) && Array.isArray(updateArr)) {
       const obj1 = this.toObject(arr)
@@ -866,7 +570,6 @@ class KeyValueObject {
     }
     return []
   }
-
   static values(arr = []) {
     if (Array.isArray(arr)) {
       return arr.reduce((acc, item) => {
@@ -913,22 +616,92 @@ class Metadata extends KeyValueObject {
     })
     return instance.isValid ? instance : null
   }
+  static get _classname() {
+    return 'Metadata'
+  }
 
-  static foundByKey(arr = [], key) {
-    const found = (arr || []).find((m) => {
-      return m.key === stringFormatter(key)
+  static merge(toArr, fromArr) {
+    (fromArr || []).map((from) => {
+      const found = toArr.find((to) => {
+        return stringFormatter(to.key) === stringFormatter(from.key)
+      })
+      if (found) {
+        found.value = (found.value || []).concat(from.value)
+      } else {
+        toArr.push(from)
+      }
     })
-    return found || null
+    return toArr
+  }
+  static sameKey(item, key) {
+    return stringFormatter(item.key) === stringFormatter(key)
+  }
+}
+
+
+
+;// ./lib/models/metadata/index.js
+
+
+
+
+;// ./lib/models/qMeta/qMeta.js
+
+
+const updateAllowedProps = [
+  'attributes',
+  'ref'
+]
+
+class QMeta {
+  constructor(options = {}) {
+    options = options || {}
+    this.attributes = KeyValueObject.initOnlyValidFromArray(options.attributes)
+    this.ref = options.ref || {}
   }
 
   static get _classname() {
-    return 'Metadata'
+    return 'QMeta'
+  }
+  static get _superclass() {
+    return 'QMeta'
+  }
+
+  // Class methods
+  static init(options = {}) {
+    if (options instanceof QMeta) {
+      return options
+    }
+    return new QMeta(options)
+  }
+
+  // instance methods
+  addAttribute(obj) {
+    const kvObject = KeyValueObject.init(obj)
+    if (!kvObject) {
+      throw new Error('invalid meta attribute')
+    }
+    this.attributes.push(kvObject)
+    return this
+  }
+
+  update(obj) {
+    Object.keys(obj).forEach((key) => {
+      if (updateAllowedProps.includes(key)) {
+        if (key === 'attributes') {
+          this[key] = KeyValueObject.initOnlyValidFromArray(obj[key])
+        } else {
+          this[key] = obj[key]
+        }
+      }
+    })
+    return this
   }
 }
 
 
 
-;// ./lib/models/metadata/index.js
+;// ./lib/models/qMeta/index.js
 
 
 
@@ -936,10 +709,22 @@ class Metadata extends KeyValueObject {
 ;// ./lib/models/repo/repo.js
 class Repo {
   constructor(options) {
+    options = options || {}
     this.model = options.model
-    this.dbTransaction = options.dbTransaction
+    this._sharedOptions = options._sharedOptions // { session: this.dbTransaction }
+    this._queryOptions = options._queryOptions
+    this._saveOptions = options._saveOptions
+    this._Class = options._constructor && options._constructor._Class
+      ? options._constructor._Class
+      : null
+  }
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
+    }
+    const instance = new this(options)
+    return instance.isValid ? instance : null
   }
-
   static get _classname() {
     return 'Repo'
   }
@@ -947,8 +732,40 @@ class Repo {
     return 'Repo'
   }
 
+  get _classname() {
+    return 'Repo'
+  }
+
+  get _superclass() {
+    return 'Repo'
+  }
+
+  get isValid() {
+    return this.model
+      && (typeof this.model.deleteOne === 'function')
+      && (typeof this.model.findAll === 'function')
+      && (typeof this.model.saveOne === 'function')
+  }
+
+  get queryOptions() {
+    return {
+      ...this._sharedOptions,
+      ...this._queryOptions,
+    }
+  }
+
+  get saveOptions() {
+    return {
+      ...this._sharedOptions,
+      ...this._saveOptions,
+    }
+  }
+
   init(options) {
-    throw new Error('subclass should implement .init(options)')
+    if (this._Class && typeof this._Class.init === 'function') {
+      return this._Class.init(options)
+    }
+    return options
   }
 
   async deleteOne({ id }) {
@@ -965,9 +782,8 @@ class Repo {
   }
 
   findAll({ query }) {
-    const options = {}
     return new Promise((resolve, reject) => {
-      this.model.findAll(query, options, (err, data, total) => {
+      this.model.findAll(query, this.queryOptions, (err, data, total) => {
         if (err) {
           reject(err)
         } else {
@@ -982,9 +798,8 @@ class Repo {
   }
 
   findOne({ query }) {
-    const options = { session: this.dbTransaction }
     return new Promise((resolve, reject) => {
-      this.model.findAll(query, options, (err, data) => {
+      this.model.findAll(query, this.queryOptions, (err, data) => {
         if (err) {
           reject(err)
         } else if (data.length === 1) {
@@ -1003,13 +818,13 @@ class Repo {
   }
 
   saveAll({ docs }) {
-    const self = this
     let isNew
     return Promise.all(docs.map(async (doc) => {
       if (doc) {
-        const result = await self.saveOne({ doc })
+        const result = await this.saveOne({ doc })
         isNew = result.isNew
-        return result.data[0]
+        const _data = result._data || result.data
+        return _data[0]
       }
       return null
     })).then((savedData) => {
@@ -1023,9 +838,8 @@ class Repo {
   }
 
   saveOne({ doc }) {
-    const options = { session: this.dbTransaction }
     return new Promise((resolve, reject) => {
-      this.model.saveOne(doc, options, (err, result) => {
+      this.model.saveOne(doc, this.saveOptions, (err, result) => {
         if (err) {
           reject(err)
         } else {
@@ -1121,9 +935,9 @@ function makeService({ repo }) {
   if (repo === undefined) {
     throw new Error('repo is required.')
   }
-  // if (!(repo instanceof Repo)) {
-  //   throw new Error('repo is not an instance of Repo.')
-  // }
+  if (repo._superclass !== Repo._superclass) {
+    throw new Error('repo is not an instance of Repo.')
+  }
   return new Service({ repo })
 }
 
@@ -1141,6 +955,7 @@ function makeService({ repo }) {
 
 
 
+
 ;// ./lib/index.js