@questwork/q-utilities 0.1.0 → 0.1.2

package/dist/index.min.cjs

@@ -0,0 +1,1154 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  ApiResponse: () => (/* reexport */ ApiResponse),
+  KeyValueObject: () => (/* reexport */ KeyValueObject),
+  Metadata: () => (/* reexport */ Metadata),
+  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),
+  stringFormatter: () => (/* reexport */ stringFormatter)
+});
+
+;// ./lib/helpers/convertString/convertString.js
+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
+  })
+}
+
+/* harmony default export */ const convertString_convertString = ({
+  convertString
+});
+
+
+;// ./lib/helpers/convertString/index.js
+
+
+;// ./lib/helpers/formatDate/formatDate.js
+
+function formatDate(date, format) {
+  const _date = date && date instanceof Date ? date : new Date(date)
+  const dayMapChi = ['日','一','二','三','四','五','六']
+  const dayMapEng = ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']
+  const dayMapEngShort = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
+  const _format = format || 'YYYY/MM/DD hh:mm'
+  const e = _date.getDay()
+  const ee = dayMapEngShort[e]
+  const eee = dayMapChi[e]
+  const eeee = dayMapEng[e]
+  const y = _date.getFullYear()
+  const m = _date.getMonth() + 1
+  const d = _date.getDate()
+  const h = _date.getHours()
+  const mm = _date.getMinutes()
+  const s = _date.getSeconds()
+
+  return _format.replace('YYYY', y)
+    .replace('MM', padding(m))
+    .replace('MM', padding(m))
+    .replace('DD', padding(d))
+    .replace('hh', padding(h))
+    .replace('mm', padding(mm))
+    .replace('ss', padding(s))
+    .replace('M', m)
+    .replace('D', d)
+    .replace('h', h)
+    .replace('m', mm)
+    .replace('s', s)
+    .replace('EEEE', padding(eeee))
+    .replace('EEE', padding(eee))
+    .replace('EE', padding(ee))
+    .replace('E', padding(e))
+}
+
+function padding(m) {
+  return m < 10 ? `0${m}` : m
+}
+
+
+/* harmony default export */ const formatDate_formatDate = ({
+  formatDate
+});
+
+
+
+;// ./lib/helpers/formatDate/index.js
+
+
+;// ./lib/helpers/getValidation/getValidation.js
+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': {
+        return value['$and'].reduce((acc, item) => (acc && getValidation(item, data, getDataByKey, KeyValueObject)), true)
+      }
+      case '$or': {
+        return value['$or'].reduce((acc, item) => (acc || getValidation(item, data, getDataByKey, KeyValueObject)), 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
+  }
+}
+
+/* harmony default export */ const getValidation_getValidation = ({
+  getValidation
+});
+
+
+;// ./lib/helpers/getValidation/index.js
+
+
+;// ./lib/helpers/getValueByKeys/getValueByKeys.js
+// keys can be array or string
+function getValueByKeys(keys, data) {
+  let _keys = keys
+  let _data = data
+  if (!Array.isArray(keys)) {
+    const { keys: keyArr, obj } = keys
+    _keys = keyArr
+    _data = obj
+  }
+  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
+
+}
+/* harmony default export */ const getValueByKeys_getValueByKeys = ({
+  getValueByKeys
+});
+
+
+
+;// ./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()
+  if (num.length < minLength) {
+    return padZeros('0' + num, minLength)
+  }
+  return num
+}
+
+
+
+;// ./lib/helpers/padZeros/index.js
+
+
+
+
+;// ./lib/helpers/stringFormatter/stringFormatter.js
+function stringFormatter(str) {
+  return (str || '').toUpperCase().replace('-', '_').replace(' ', '_')
+}
+
+
+
+;// ./lib/helpers/stringFormatter/index.js
+
+
+
+
+;// ./lib/helpers/index.js
+
+
+
+
+
+
+
+
+;// ./lib/models/apiResponse/apiResponse.js
+class ApiResponse {
+  constructor(options = {}) {
+    options = options || {}
+    this._data = options.data || options._data || []
+    this.err = options.err
+    this.isNew = options.isNew || false
+    this.message = options.message
+    this.total = options.total || 0
+    this._instanceBuilder = options._instanceBuilder
+  }
+
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
+    }
+    const instance = new this(options)
+    return instance
+  }
+  static get _classname() {
+    return 'ApiResponse'
+  }
+  static get _superclass() {
+    return 'ApiResponse'
+  }
+
+  // getters
+  get data() {
+    if (this._instanceBuilder && (typeof this._instanceBuilder === 'function')) {
+      return this._data.map(this._instanceBuilder)
+    }
+    return this._data
+  }
+}
+
+
+
+;// ./lib/models/apiResponse/makeApiResponse.js
+
+
+function makeApiResponse({ repo, result }) {
+  return ApiResponse.init({
+    ...result,
+    _instanceBuilder: (i) => {
+      return repo.init(i)
+    }
+  })
+}
+
+
+
+;// ./lib/models/apiResponse/index.js
+
+
+
+
+
+;// ./lib/models/keyValueObject/keyValueObject.js
+class KeyValueObject {
+  constructor(options = {}) {
+    options = options || {}
+    this.key = options.key || null
+    this.value = (typeof options.value !== 'undefined') ? options.value : ''
+  }
+
+  // Class methods
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
+    }
+    const instance = new this(options)
+    return instance.isValid ? instance : null
+  }
+  static initFromArray(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.map((a) => this.init(a))
+    }
+    return []
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+  static get _classname() {
+    return 'KeyValueObject'
+  }
+  static get _superclass() {
+    return 'KeyValueObject'
+  }
+
+  static addItem(arr, key, value) {
+    arr.push(
+      { key, value }
+    )
+  }
+  static addRecord(arr = [], key, value) {
+    const self = this
+    if (!this.hasKeyValue(arr, key, value)) {
+      arr.push(self.init({ key, value }))
+    }
+    return arr
+  }
+
+  static appendRecord(arr = [], key, value) {
+    return arr.map((item) => {
+      if (item.key === 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)
+      }
+      return acc
+    }, [])
+  }
+
+  static foundByKey(arr = [], key) {
+    const found = arr.find((m) => {
+      return m.key === key
+    })
+    return found || null
+  }
+
+  static foundValueByKey(arr = [], key) {
+    const found = this.foundByKey(arr, key)
+    return found ? found.value : null
+  }
+
+  static getValueByKey(arr = [], key) {
+    const found = arr.find((i) => {
+      return i.key === key
+    })
+    if (found) {
+      return found.value
+    }
+    return null
+  }
+
+  static getValueByKeyFromArray(arr = [], key) {
+    if (arr.length === 0) {
+      return null
+    }
+    const firstArr = arr.shift()
+    const found = firstArr.find((i) => {
+      return i.key === 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) {
+        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 insertOrUpdateRecord(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 keys(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc.push(item.key)
+        return acc
+      }, [])
+    }
+    return []
+  }
+
+  static merge(toArr, fromArr) {
+    (fromArr || []).map((from) => {
+      const found = toArr.find((to) => {
+        return to.key === from.key
+      })
+      if (found) {
+        found.value = (found.value || []).concat(from.value)
+      } else {
+        toArr.push(from)
+      }
+    })
+    return toArr
+  }
+
+  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) {
+        return {
+          ...item,
+          value
+        }
+      }
+      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)
+      const obj2 = this.toObject(updateArr)
+      return this.fromObject({
+        ...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
+  }
+}
+
+
+
+;// ./lib/models/keyValueObject/index.js
+
+
+
+
+;// ./lib/models/metadata/metadata.js
+
+
+
+class Metadata extends KeyValueObject {
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
+    }
+    const instance = new this({
+      ...options,
+      key: stringFormatter(options.key),
+    })
+    return instance.isValid ? instance : null
+  }
+
+  static foundByKey(arr = [], key) {
+    const found = (arr || []).find((m) => {
+      return m.key === stringFormatter(key)
+    })
+    return found || null
+  }
+
+  static get _classname() {
+    return 'Metadata'
+  }
+}
+
+
+
+;// ./lib/models/metadata/index.js
+
+
+
+
+;// ./lib/models/repo/repo.js
+class Repo {
+  constructor(options) {
+    this.model = options.model
+    this.dbTransaction = options.dbTransaction
+  }
+
+  static get _classname() {
+    return 'Repo'
+  }
+  static get _superclass() {
+    return 'Repo'
+  }
+
+  init(options) {
+    throw new Error('subclass should implement .init(options)')
+  }
+
+  async deleteOne({ id }) {
+    try {
+      const result = await this.model.deleteOne({ _id: id })
+      return {
+        ...result, // { message: 'ok', total }
+        isNew: false,
+        data: []
+      }
+    } catch (err) {
+      throw err
+    }
+  }
+
+  findAll({ query }) {
+    const options = {}
+    return new Promise((resolve, reject) => {
+      this.model.findAll(query, options, (err, data, total) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve({
+            isNew: false,
+            data,
+            total: total || data.length
+          })
+        }
+      })
+    })
+  }
+
+  findOne({ query }) {
+    const options = { session: this.dbTransaction }
+    return new Promise((resolve, reject) => {
+      this.model.findAll(query, options, (err, data) => {
+        if (err) {
+          reject(err)
+        } else if (data.length === 1) {
+          resolve({
+            isNew: false,
+            data,
+            total: 1
+          })
+        } else if (data.length === 0) {
+          reject(new Error('record not found'))
+        } else {
+          reject(new Error('more than one is found'))
+        }
+      })
+    })
+  }
+
+  saveAll({ docs }) {
+    const self = this
+    let isNew
+    return Promise.all(docs.map(async (doc) => {
+      if (doc) {
+        const result = await self.saveOne({ doc })
+        isNew = result.isNew
+        return result.data[0]
+      }
+      return null
+    })).then((savedData) => {
+      if (savedData.length !== 1) isNew = null
+      return {
+        data: savedData,
+        isNew,
+        total: savedData.length
+      }
+    })
+  }
+
+  saveOne({ doc }) {
+    const options = { session: this.dbTransaction }
+    return new Promise((resolve, reject) => {
+      this.model.saveOne(doc, options, (err, result) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(result)
+        }
+      })
+    })
+  }
+}
+
+
+
+;// ./lib/models/repo/index.js
+
+
+
+
+;// ./lib/models/service/service.js
+
+
+
+class Service {
+  constructor({ repo }) {
+    this.repo = repo
+  }
+
+  static get _classname() {
+    return 'Service'
+  }
+  static get _superclass() {
+    return 'Service'
+  }
+
+  deleteOne({ id }) {
+    return this.repo.deleteOne({ id })
+      .catch(() => {
+        throw new Error(`Not found for query: ${id}`)
+      })
+  }
+
+  async findAll({ query = {} } = {}) {
+    const result = await this.repo.findAll({ query })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
+  }
+
+  async findOne({ query = {} } = {}) {
+    const result = await this.repo.findOne({ query })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
+  }
+
+  init(options) {
+    return this.repo.init(options)
+  }
+  initFromArray(arr = []) {
+    return arr.map((i) => this.init(i))
+  }
+
+  async saveAll({ docs = [] } = {}) {
+    const copies = docs.map((doc) => {
+      return this.init(doc)
+    })
+    const result = await this.repo.saveAll({ docs: copies })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
+  }
+
+  async saveOne({ doc = {} } = {}) {
+    const copy = this.init(doc)
+    if (copy) {
+      const result = await this.repo.saveOne({ doc: copy })
+      return makeApiResponse({
+        repo: this.repo,
+        result
+      })
+    }
+    return {
+      isNew: null,
+      data: [],
+      err: new Error('doc is not a valid instance')
+    }
+  }
+}
+
+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.')
+  // }
+  return new Service({ repo })
+}
+
+
+
+;// ./lib/models/service/index.js
+
+
+
+
+;// ./lib/models/index.js
+
+
+
+
+
+
+;// ./lib/index.js
+
+
+
+;// ./index.js
+
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});