@questwork/q-utilities 0.1.1 → 0.1.2

package/lib/jwtHelper/jwtHelper.js

@@ -1,254 +0,0 @@
-// '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

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

package/lib/keyValueObject/keyValueObject.js

@@ -1,163 +0,0 @@
-'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
-}