@questwork/q-utilities 0.1.1 → 0.1.3

package/dist/index.min.js

@@ -0,0 +1,964 @@
+/******/ // 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))
+/******/ })();
+/******/ 
+/************************************************************************/
+var __webpack_exports__ = {};
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  sh: () => (/* reexport */ ApiResponse),
+  Yc: () => (/* reexport */ KeyValueObject),
+  OS: () => (/* reexport */ Metadata),
+  Z8: () => (/* reexport */ QMeta),
+  lc: () => (/* reexport */ Repo),
+  kl: () => (/* reexport */ Service),
+  l0: () => (/* reexport */ convertString),
+  Yq: () => (/* reexport */ formatDate),
+  G8: () => (/* reexport */ getValidation),
+  pY: () => (/* reexport */ getValueByKeys),
+  su: () => (/* reexport */ makeApiResponse),
+  Q6: () => (/* reexport */ makeService),
+  Lv: () => (/* reexport */ padZeros),
+  Qy: () => (/* 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/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/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 '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/qMeta/index.js
+
+
+
+
+;// ./lib/models/repo/repo.js
+class Repo {
+  constructor(options) {
+    options = options || {}
+    this.model = options.model
+    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'
+  }
+  static get _superclass() {
+    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) {
+    if (this._Class && typeof this._Class.init === 'function') {
+      return this._Class.init(options)
+    }
+    return 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 }) {
+    return new Promise((resolve, reject) => {
+      this.model.findAll(query, this.queryOptions, (err, data, total) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve({
+            isNew: false,
+            data,
+            total: total || data.length
+          })
+        }
+      })
+    })
+  }
+
+  findOne({ query }) {
+    return new Promise((resolve, reject) => {
+      this.model.findAll(query, this.queryOptions, (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 }) {
+    let isNew
+    return Promise.all(docs.map(async (doc) => {
+      if (doc) {
+        const result = await this.saveOne({ doc })
+        isNew = result.isNew
+        const _data = result._data || result.data
+        return _data[0]
+      }
+      return null
+    })).then((savedData) => {
+      if (savedData.length !== 1) isNew = null
+      return {
+        data: savedData,
+        isNew,
+        total: savedData.length
+      }
+    })
+  }
+
+  saveOne({ doc }) {
+    return new Promise((resolve, reject) => {
+      this.model.saveOne(doc, this.saveOptions, (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._superclass !== Repo._superclass) {
+    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
+
+
+var __webpack_exports__ApiResponse = __webpack_exports__.sh;
+var __webpack_exports__KeyValueObject = __webpack_exports__.Yc;
+var __webpack_exports__Metadata = __webpack_exports__.OS;
+var __webpack_exports__QMeta = __webpack_exports__.Z8;
+var __webpack_exports__Repo = __webpack_exports__.lc;
+var __webpack_exports__Service = __webpack_exports__.kl;
+var __webpack_exports__convertString = __webpack_exports__.l0;
+var __webpack_exports__formatDate = __webpack_exports__.Yq;
+var __webpack_exports__getValidation = __webpack_exports__.G8;
+var __webpack_exports__getValueByKeys = __webpack_exports__.pY;
+var __webpack_exports__makeApiResponse = __webpack_exports__.su;
+var __webpack_exports__makeService = __webpack_exports__.Q6;
+var __webpack_exports__padZeros = __webpack_exports__.Lv;
+var __webpack_exports__stringFormatter = __webpack_exports__.Qy;
+export { __webpack_exports__ApiResponse as ApiResponse, __webpack_exports__KeyValueObject as KeyValueObject, __webpack_exports__Metadata as Metadata, __webpack_exports__QMeta as QMeta, __webpack_exports__Repo as Repo, __webpack_exports__Service as Service, __webpack_exports__convertString as convertString, __webpack_exports__formatDate as formatDate, __webpack_exports__getValidation as getValidation, __webpack_exports__getValueByKeys as getValueByKeys, __webpack_exports__makeApiResponse as makeApiResponse, __webpack_exports__makeService as makeService, __webpack_exports__padZeros as padZeros, __webpack_exports__stringFormatter as stringFormatter };