@questwork/q-utilities 0.1.11 → 0.1.13

package/dist/{index.min.js → q-utilities.min.js}

@@ -1,50 +1,79 @@
-/******/ // The require scope
-/******/ var __webpack_require__ = {};
-/******/ 
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["@questwork/q-utilities"] = factory();
+	else
+		root["@questwork/q-utilities"] = factory();
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	// 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/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/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__, {
-  sh: () => (/* reexport */ ApiResponse),
-  Yc: () => (/* reexport */ KeyValueObject),
-  OS: () => (/* reexport */ Metadata),
-  Z8: () => (/* reexport */ QMeta),
-  lc: () => (/* reexport */ Repo),
-  kl: () => (/* reexport */ Service),
-  Mg: () => (/* reexport */ TemplateCompiler),
-  _x: () => (/* reexport */ UniqueKeyGenerator),
-  yl: () => (/* reexport */ concatStringByArray),
-  l0: () => (/* reexport */ convertString),
-  Yq: () => (/* reexport */ formatDate),
-  zn: () => (/* reexport */ generalPost),
-  G8: () => (/* reexport */ getValidation),
-  pY: () => (/* reexport */ getValueByKeys),
-  su: () => (/* reexport */ makeApiResponse),
-  Q6: () => (/* reexport */ makeService),
-  UI: () => (/* reexport */ objectHelper),
-  d: () => (/* reexport */ pReduce),
-  Lv: () => (/* reexport */ padZeros),
-  Qy: () => (/* reexport */ stringFormatter),
-  yO: () => (/* reexport */ stringHelper)
+  ApiResponse: () => (/* reexport */ ApiResponse),
+  KeyValueObject: () => (/* reexport */ KeyValueObject),
+  Metadata: () => (/* reexport */ Metadata),
+  QMeta: () => (/* reexport */ QMeta),
+  Repo: () => (/* reexport */ Repo),
+  Service: () => (/* reexport */ Service),
+  TemplateCompiler: () => (/* reexport */ TemplateCompiler),
+  TenantAwareEntity: () => (/* reexport */ TenantAwareEntity),
+  TrackedEntity: () => (/* reexport */ TrackedEntity),
+  UniqueKeyGenerator: () => (/* reexport */ UniqueKeyGenerator),
+  concatStringByArray: () => (/* reexport */ concatStringByArray),
+  convertString: () => (/* reexport */ convertString),
+  formatDate: () => (/* reexport */ formatDate),
+  generalPost: () => (/* reexport */ generalPost),
+  getValidation: () => (/* reexport */ getValidation),
+  getValueByKeys: () => (/* reexport */ getValueByKeys_getValueByKeys),
+  init: () => (/* reexport */ init),
+  initFromArray: () => (/* reexport */ initFromArray),
+  initOnlyValidFromArray: () => (/* reexport */ initOnlyValidFromArray),
+  makeApiResponse: () => (/* reexport */ makeApiResponse),
+  makeService: () => (/* reexport */ makeService),
+  objectHelper: () => (/* reexport */ objectHelper),
+  pReduce: () => (/* reexport */ pReduce),
+  padZeros: () => (/* reexport */ padZeros),
+  stringFormatter: () => (/* reexport */ stringFormatter),
+  stringHelper: () => (/* reexport */ stringHelper)
 });
 
 ;// ./lib/helpers/getValidation/getValidation.js
@@ -235,7 +264,7 @@ function padding(m) {
 
 ;// ./lib/helpers/getValueByKeys/getValueByKeys.js
 // keys can be array or object or string
-function getValueByKeys(keys, data) {
+function getValueByKeys_getValueByKeys(keys, data) {
   let _keys = keys
   let _data = data
   if (typeof keys === 'string') {
@@ -251,7 +280,7 @@ function getValueByKeys(keys, data) {
   }
   const firstKey = _keys.shift()
   if (_data && Object.prototype.hasOwnProperty.call(_data, firstKey)) {
-    return getValueByKeys(_keys, _data[firstKey])
+    return getValueByKeys_getValueByKeys(_keys, _data[firstKey])
   }
   if (_data && firstKey) {
     return _data[firstKey]
@@ -259,12 +288,11 @@ function getValueByKeys(keys, data) {
   return _data
 
 }
-/* harmony default export */ const getValueByKeys_getValueByKeys = ({
-  getValueByKeys
+/* harmony default export */ const getValueByKeys = ({
+  getValueByKeys: getValueByKeys_getValueByKeys
 });
 
 
-
 ;// ./lib/helpers/getValueByKeys/index.js
 
 
@@ -292,7 +320,25 @@ class TemplateCompilerException extends Error {
 ;// ./lib/models/templateCompiler/constants.js
 const _EMPTY = '_EMPTY'
 const _FN_NAMES = [
-  'get', 'map', 'join', 'concatIf', 'exec', 'filterOne', 'filterAll', 'formatDate', 'eq', 'neq', 'gt', 'lt', 'gte', 'lte', 'isEmpty', 'isNotEmpty', 'toLowerCase', 'toUpperCase'
+  'concatIf',
+  'divide',
+  'eq',
+  'exec',
+  'filterAll',
+  'filterOne',
+  'formatDate',
+  'get',
+  'gt',
+  'gte',
+  'isEmpty',
+  'isNotEmpty',
+  'join',
+  'lt',
+  'lte',
+  'map',
+  'neq',
+  'toLowerCase',
+  'toUpperCase',
 ]
 const _HIDE = '_HIDE'
 const _NOT_EMPTY = '_NOT_EMPTY'
@@ -333,6 +379,20 @@ function _concatIf(data, args) {
 
 
 
+;// ./lib/models/templateCompiler/helpers/_divide.js
+function _divide(value, divisor) {
+  try {
+    if (Number.isNaN(value)) {
+      return value
+    }
+    return (value / divisor)
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
 ;// ./lib/models/templateCompiler/helpers/_eq.js
 
 
@@ -404,7 +464,7 @@ function _existObject(data, args) {
     const arg = args[0]
     return data.filter((e) => {
       if (arg.includes('.')) {
-        return getValueByKeys(arg.split('.'), e)
+        return getValueByKeys_getValueByKeys(arg.split('.'), e)
       }
       return Object.prototype.hasOwnProperty.call(e, arg)
     })
@@ -422,7 +482,7 @@ function _existObject(data, args) {
   const [key, ..._argsArr] = args
   const _args = _argsArr.flat()
   return data.filter((e) => {
-    const value = key.includes('.') ? getValueByKeys(key.split('.'), e) : e[key]
+    const value = key.includes('.') ? getValueByKeys_getValueByKeys(key.split('.'), e) : e[key]
     return _args.some((arg) => _performOperation(arg, value))
   })
 }
@@ -918,6 +978,7 @@ function _toUpperCase(data, args) {
 
 
 
+
 
 
 ;// ./lib/models/templateCompiler/templateCompiler.js
@@ -944,6 +1005,9 @@ class TemplateCompiler {
   static concatIf(data, args) {
     return _concatIf(data, args)
   }
+  static divide(data, args) {
+    return _divide(data, args)
+  }
   static eq(data, args) {
     return _eq(data, args)
   }
@@ -955,7 +1019,6 @@ class TemplateCompiler {
   static formatDate(data, args) {
     return _formatDate(data, args)
   }
-  
   static get(data, key, failover = null) {
     return _get(data, key, failover)
   }
@@ -1077,6 +1140,10 @@ function _parseSinglePart(input) {
       // 去掉双引号，返回
       return input.substring(1, input.length - 1)
     }
+    if (input.startsWith("'") && input.endsWith("'")) {
+      // 去掉双引号，返回
+      return input.substring(1, input.length - 1)
+    }
 
     const _input = _toBasicType(input)
 
@@ -1104,6 +1171,10 @@ function _toBasicType(input) {
     // 去掉双引号，返回
     return input.substring(1, input.length - 1)
   }
+  if (input.startsWith("'") && input.endsWith("'")) {
+    // 去掉双引号，返回
+    return input.substring(1, input.length - 1)
+  }
   if (input === 'true') {
     return true
   }
@@ -1126,8 +1197,20 @@ function _callFunction(data, functionName, parameters) {
   try {
     let failover
     switch (functionName) {
+      case 'concatIf':
+        return _concatIf(data, parameters)
+      case 'divide':
+        return _divide(data, parameters)
+      case 'eq':
+        return _eq(data, parameters)
       case 'exec':
         return _exec(data, parameters)
+      case 'filterAll':
+        return _filterAll(data, parameters)
+      case 'filterOne':
+        return _filterOne(data, parameters)
+      case 'formatDate':
+        return _formatDate(data, parameters)
       case 'get':
         if (parameters.length > 2) {
           throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException)
@@ -1136,34 +1219,24 @@ function _callFunction(data, functionName, parameters) {
           failover = parameters[parameters.length - 1]
         }
         return _get(data, parameters[0], failover)
-      case 'join':
-        return _join(data, parameters[0])
-      case 'map':
-        return _map(data, parameters)
-      case 'concatIf':
-        return _concatIf(data, parameters)
-      case 'filterOne':
-        return _filterOne(data, parameters)
-      case 'filterAll':
-        return _filterAll(data, parameters)
-      case 'formatDate':
-        return _formatDate(data, parameters)
-      case 'eq':
-        return _eq(data, parameters)
-      case 'neq':
-        return _neq(data, parameters)
       case 'gt':
         return _gt(data, parameters)
       case 'gte':
         return _gte(data, parameters)
-      case 'lt':
-        return _lt(data, parameters)
-      case 'lte':
-        return _lte(data, parameters)
       case 'isEmpty':
         return _isEmpty(data, parameters)
       case 'isNotEmpty':
         return _isNotEmpty(data, parameters)
+      case 'join':
+        return _join(data, parameters[0])
+      case 'lt':
+        return _lt(data, parameters)
+      case 'lte':
+        return _lte(data, parameters)
+      case 'map':
+        return _map(data, parameters)
+      case 'neq':
+        return _neq(data, parameters)
       case 'toLowerCase':
         return _toLowerCase(data)
       case 'toUpperCase':
@@ -1194,21 +1267,21 @@ function concatStringByArray(arrTemplate, data) {
     const { type, value = '', restriction, template, format, showMinutes } = item
     switch (type) {
       case('label'): {
-        if (getValidation(restriction, data, getValueByKeys)) {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
           acc += (value.toString())
         }
         break
       }
       case('value'): {
-        if (getValidation(restriction, data, getValueByKeys)) {
-          const _value = getValueByKeys(value.split('.'), data) || ''
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
           acc += (_value.toString())
         }
         break 
       }
       case('array'): {
-        if (getValidation(restriction, data, getValueByKeys)) {
-          const _value = getValueByKeys(value.split('.'), data) || []
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || []
           acc += _value.reduce((_acc, item) => {
             return _acc += concatStringByArray(template, item)
           }, '')
@@ -1216,9 +1289,9 @@ function concatStringByArray(arrTemplate, data) {
         break 
       }
       case('ellipsis'): {
-        if (getValidation(restriction, data, getValueByKeys)) {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
           const { maxLength } = item
-          const _value = getValueByKeys(value.split('.'), data) || ''
+          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
           if (_value.length <= maxLength) {
             acc += (_value.toString())
           } else {
@@ -1228,14 +1301,14 @@ function concatStringByArray(arrTemplate, data) {
         break 
       }
       case ('date'): {
-        if (getValidation(restriction, data, getValueByKeys)) {
-          const _value = getValueByKeys(value.split('.'), data) || ''
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
           acc += (formatDate(_value, format).toString())
         }
         break
       }
       case ('templateCompiler'): {
-        if (getValidation(restriction, data, getValueByKeys)) {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
           const templateCompiler = new TemplateCompiler({ data })
           acc += templateCompiler.pipe(value)
         }
@@ -1255,13 +1328,16 @@ function concatStringByArray(arrTemplate, data) {
 
 
 ;// ./lib/helpers/convertString/convertString.js
+
+
 function convertString(string, patternMatch = /\$\{(.+?)\}/g, value, getValueByKeys) {
-  if (!string || typeof getValueByKeys !== 'function') {
+  if (!string) {
     return ''
   }
+  let _getValueByKeys = typeof getValueByKeys !== 'function' ? getValueByKeys : getValueByKeys_getValueByKeys
   const reg = new RegExp(patternMatch, 'g')
   return string.replace(reg, (match, key) => {
-    const result = getValueByKeys({ keys: key.split('.'), obj: value })
+    const result = _getValueByKeys({ keys: key.split('.'), obj: value })
     if (result === null || result === undefined) {
       return ''
     }
@@ -1412,282 +1488,468 @@ async function pReduce(iterable, reducer, initialValue) {
 
 
 
-;// ./lib/models/apiResponse/apiResponse.js
-class ApiResponse {
-  constructor(options = {}) {
+;// ./lib/models/repo/repo.js
+class Repo {
+  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
+    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
+    return instance.isValid ? instance : null
   }
   static get _classname() {
-    return 'ApiResponse'
+    return 'Repo'
   }
   static get _superclass() {
-    return 'ApiResponse'
+    return 'Repo'
   }
 
-  // getters
-  get data() {
-    if (this._instanceBuilder && (typeof this._instanceBuilder === 'function')) {
-      return this._data.map(this._instanceBuilder)
-    }
-    return this._data
+  get _classname() {
+    return 'Repo'
   }
-}
-
 
+  get _superclass() {
+    return 'Repo'
+  }
 
-;// ./lib/models/apiResponse/makeApiResponse.js
-
+  get isValid() {
+    return this.model
+      && (typeof this.model.deleteOne === 'function')
+      && (typeof this.model.findAll === 'function')
+      && (typeof this.model.saveOne === 'function')
+  }
 
-function makeApiResponse({ repo, result }) {
-  return ApiResponse.init({
-    ...result,
-    _instanceBuilder: (i) => {
-      return repo.init(i)
+  get queryOptions() {
+    return {
+      ...this._sharedOptions,
+      ...this._queryOptions,
     }
-  })
-}
-
-
-
-;// ./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
+  get saveOptions() {
+    return {
+      ...this._sharedOptions,
+      ...this._saveOptions,
     }
-    const instance = new this(options)
-    return instance.isValid ? instance : null
   }
-  static initFromArray(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.map((a) => this.init(a))
+
+  init(options) {
+    if (this._Class && typeof this._Class.init === 'function') {
+      return this._Class.init(options)
     }
-    return []
-  }
-  static initOnlyValidFromArray(arr = []) {
-    return this.initFromArray(arr).filter((i) => i)
-  }
-  static get _classname() {
-    return 'KeyValueObject'
-  }
-  static get _superclass() {
-    return 'KeyValueObject'
+    return options
   }
 
-  static addItem(arr, key, value) {
-    arr.push(this.init({ key, value }))
-  }
-  static addRecord(arr = [], key, value) {
-    if (!this.hasKeyValue(arr, key, value)) {
-      arr.push(this.init({ key, value }))
+  async deleteOne({ id }) {
+    try {
+      const result = await this.model.deleteOne({ _id: id })
+      return {
+        ...result, // { message: 'ok', total }
+        isNew: false,
+        data: []
+      }
+    } catch (err) {
+      throw err
     }
-    return arr
   }
-  static appendRecord(arr = [], key, value) {
-    return arr.map((item) => {
-      if (this.sameKey(item, key)) {
-        item.value = [...item.value, ...value]
-      }
-      return item
+
+  // systemLog is optional
+  findAll({ query, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_READ',
+      message: `fn ${this._classname}.prototype.findAll`,
+      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
     })
-  }
-  static appendValueArray(arr = [], key, value) {
-    return arr.map((item) => {
-      if (this.sameKey(item, key)) {
-        item.value = [...item.value, ...value]
-      }
-      return item
+    return new Promise((resolve, reject) => {
+      this.model.findAll(query, this.queryOptions, (err, data, total) => {
+        if (err) {
+          log({ level: 'warn', output: err.toString() })
+          reject(err)
+        } else {
+          const result = {
+            isNew: false,
+            data,
+            total: total || data.length
+          }
+          log({ level: 'info', output: { ...result } })
+          resolve(result)
+        }
+      })
     })
   }
-  static foundByKey(arr = [], key) {
-    const found = arr.find((m) => {
-      return this.sameKey(m, key)
+
+  findOne({ query, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_READ',
+      message: `fn ${this._classname}.prototype.findOne`,
+      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
     })
-    return found || null
-  }
-  static foundValueByKey(arr = [], key) {
-    const found = this.foundByKey(arr, key)
-    return found ? found.value : null
+    return new Promise((resolve, reject) => {
+      this.model.findAll(query, this.queryOptions, (err, data) => {
+        if (err) {
+          reject(err)
+        } else if (data.length === 1) {
+          const result = {
+            isNew: false,
+            data,
+            total: 1
+          }
+          log({ level: 'info', output: { ...result } })
+          resolve(result)
+        } else if (data.length === 0) {
+          reject(new Error('record not found'))
+        } else {
+          reject(new Error('more than one is found'))
+        }
+      })
+    })
+      .catch((err) => {
+        log({ level: 'warn', output: err.toString() })
+        throw err
+      })
   }
-  static fromObject(options = {}) {
-    return Object.keys(options).reduce((acc, key) => {
-      acc.push(this.init({ key, value: options[key] }))
-      return acc
-    }, [])
-  }
-  static getValueByKey(arr = [], key) {
-    return this.foundValueByKey(arr, key)
+
+  saveAll({ docs, systemLog }) {
+    let isNew
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_WRITE',
+      message: `fn ${this._classname}.prototype.saveAll`,
+      input: [{ docs: [...docs], systemLog: { ...systemLog } }]
+    })
+    const promise = typeof this.model.saveAll === 'function'
+      ? this.model.saveAll({ docs })
+      : 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
+      }))
+    return promise.then((savedData) => {
+      if (savedData.length !== 1) isNew = null
+      const result = {
+        data: savedData,
+        isNew,
+        total: savedData.length
+      }
+      log({ level: 'info', output: { ...result } })
+      return result
+    }).catch((err) => {
+      log({ level: 'warn', output: err.toString() })
+      throw err
+    })
   }
-  static getValueByKeyFromArray(arr = [], key) {
-    if (arr.length === 0) {
-      return null
-    }
-    const firstArr = arr.shift()
-    const found = firstArr.find((i) => {
-      return this.sameKey(i, key)
+
+  saveOne({ doc, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_WRITE',
+      message: `fn ${this._classname}.prototype.saveOne`,
+      input: [{ doc: { ...doc }, systemLog: { ...systemLog } }]
     })
-    if (found && found.value) {
-      return found.value
+    return new Promise((resolve, reject) => {
+      this.model.saveOne(doc, this.saveOptions, (err, result) => {
+        if (err) {
+          log({ level: 'warn', output: err.toString() })
+          reject(err)
+        } else {
+          log({ level: 'info', output: { ...result } })
+          resolve(result)
+        }
+      })
+    })
+  }
+}
+
+function _makeLog({ systemLog, label, message: message1, input } = {}) {
+  return ({ level, messgae: massage2, output } = {}) => {
+    if (systemLog && systemLog.systemLogHelper) {
+      systemLog.systemLogHelper.log({
+        batchId: systemLog.batchId,
+        label,
+        level,
+        message: massage2 || message1,
+        data: {
+          payload: {
+            input,
+            output
+          }
+        }
+      })
     }
-    return this.getValueByKeyFromArray(arr, key)
   }
-  static getValuesByKey(arr = [], key) {
-    return arr.reduce((acc, item) => {
-      if (this.sameKey(item, key)) {
-        acc.push(item.value)
-      }
-      return acc
-    }, [])
+}
+
+
+
+;// ./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 hasKeyValue(arr = [], key, value) {
-    if (typeof value === 'undefined') {
-      return arr.filter((item) => this.sameKey(item, key)).length > 0
+
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
     }
-    return arr.filter((item) => (this.sameKey(item, key) && _isSame(item.value, value))).length > 0
+    const instance = new this(options)
+    return instance
   }
-  static insertOrUpdateRecord(arr = [], key, value) {
-    let copy = [...arr]
-    if (!this.hasKeyValue(arr, key)) {
-      copy.push(this.init({ key, value }))
-    } else {
-      copy = this.updateRecord(arr, key, value)
+  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 copy
+    return this._data
   }
-  static keys(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc.push(item.key)
-        return acc
-      }, [])
+}
+
+
+
+;// ./lib/models/apiResponse/makeApiResponse.js
+
+
+function makeApiResponse({ repo, result }) {
+  return ApiResponse.init({
+    ...result,
+    _instanceBuilder: (i) => {
+      return repo.init(i)
     }
-    return []
+  })
+}
+
+
+
+;// ./lib/models/service/service.js
+
+
+
+class Service {
+  constructor({ repo }) {
+    this.repo = repo
   }
-  static merge(toArr, fromArr) {
-    (fromArr || []).map((from) => {
-      const found = toArr.find((to) => {
-        return to.key === from.key
+
+  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}`)
       })
-      if (found) {
-        found.value = (found.value || []).concat(from.value)
-      } else {
-        toArr.push(from)
-      }
+  }
+
+  async findAll({ query = {}, systemLog } = {}) {
+    const result = await this.repo.findAll({ query, systemLog })
+    return makeApiResponse({
+      repo: this.repo,
+      result
     })
-    return toArr
   }
-  static removeByKey(arr, key) {
-    return arr.reduce((acc, item) => {
-      if (!this.sameKey(item, key)) {
-        acc.push(item)
-      }
-      return acc
-    }, [])
+
+  async findOne({ query = {}, systemLog } = {}) {
+    const result = await this.repo.findOne({ query, systemLog })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
   }
-  static sameKey(item, key) {
-    return _isSame(item.key, key)
+
+  init(options) {
+    return this.repo.init(options)
   }
-  static toObject(arr = []) {
+  initFromArray(arr = []) {
     if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc[item.key] = item.value
-        return acc
-      }, {})
+      return arr.map((a) => this.init(a))
     }
-    return {}
+    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 ''
+  initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
   }
-  static updateRecord(arr = [], key, value) {
-    return arr.map((item) => {
-      if (this.sameKey(item, key)) {
-        return {
-          ...item,
-          value
-        }
-      }
-      return item
+
+  async saveAll({ docs = [], config = {}, systemLog } = {}) {
+    const copies = docs.map((doc) => {
+      return config.skipInit ? doc : this.init(doc)
+    })
+    const result = await this.repo.saveAll({ docs: copies, systemLog })
+    return makeApiResponse({
+      repo: this.repo,
+      result
     })
   }
-  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
+
+  // set skipInit to true if we want to use POST for query
+  async saveOne({ doc = {}, config = {}, systemLog } = {}) {
+    const copy = config.skipInit ? doc : this.init(doc)
+    if (copy) {
+      const result = await this.repo.saveOne({ doc: copy, systemLog })
+      return makeApiResponse({
+        repo: this.repo,
+        result
       })
     }
-    return []
-  }
-  static values(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc.push(item.value)
-        return acc
-      }, [])
+    return {
+      isNew: null,
+      data: [],
+      err: new Error('doc is not a valid instance')
     }
-    return []
   }
+}
 
-  // getters
-  get isValid() {
-    return !!this.key
+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 })
+}
 
-  get toObject() {
-    const obj = {}
-    if (this.isValid) {
-      obj[this.key] = this.value
-    }
-    return obj
+
+
+;// ./lib/helpers/generalPost/generalPost.js
+
+
+
+
+
+async function generalPost({ body = {}, GeneralModel, UniqueKeyGenerator, resourceInfo }) {
+  const { resources, data, globalShared = {}, shared = {}, relationship = {} } = body
+  const _resourceInfo = resourceInfo || body.resourceInfo
+  _attachShared(data, globalShared, shared)
+  const obj = await pReduce(resources, async (acc, resource) => {
+    const service = _makeService(resource, _resourceInfo, UniqueKeyGenerator, GeneralModel)
+    _createRelationship(data, relationship[resource], acc)
+    const _data = data[resource]
+    const result = await service.saveAll({ docs: [].concat(_data) })
+    acc[resource] = Array.isArray(_data) ? result._data : result._data[0]
+    return acc
+  }, {})
+  return obj
+}
+
+function _attachShared(data, globalShared = {}, shared = {}) {
+  Object.keys(shared).forEach((key) => {
+    const _data = data[key]
+    data[key] = objectHelper.merge({}, _data, globalShared, shared[key] || {})
+  })
+}
+
+function _createRelationship(data, relationship = {}, object) {
+  Object.keys(relationship).forEach((key) => {
+    const path = relationship[key]
+    const val = objectHelper.get(object, path)
+    objectHelper.set(data, key, val)
+  })
+}
+
+function _makeService(resource, resourceInfo, UniqueKeyGenerator, GeneralModel) {
+  const { collectionName, fields } = resourceInfo[resource]
+  const uniqueKeyGenerator = UniqueKeyGenerator.makeGenerator(fields)
+  const model = new GeneralModel({ collectionName, uniqueKeyGenerator })
+  return makeService({
+    repo: new Repo({ model })
+  })
+}
+
+
+
+;// ./lib/helpers/generalPost/index.js
+
+
+
+
+;// ./lib/helpers/init/init.js
+function init(_class, options) {
+  if (options instanceof _class) {
+    return options
+  }
+  try {
+    const instance = new _class(options)
+    return instance.isValid ? instance : null
+  } catch (e) {
+    console.log(`init failed for class: ${_class._classname || 'no _classname'}`, e)
+    return null
   }
 }
 
-function _isSame(key1, key2) {
-  return key1 === key2
+;// ./lib/helpers/init/index.js
+
+
+;// ./lib/helpers/initFromArray/initFromArray.js
+
+
+function initFromArray(_class, arr) {
+  if (Array.isArray(arr)) {
+    return arr.map((a) => init(_class, a))
+  }
+  return []
 }
 
+;// ./lib/helpers/initFromArray/index.js
 
 
-;// ./lib/models/keyValueObject/index.js
+;// ./lib/helpers/initOnlyValidFromArray/initOnlyValidFromArray.js
+
+
+function initOnlyValidFromArray(_class, arr) {
+  return initFromArray(_class, arr).filter((i) => i)
+}
+
+;// ./lib/helpers/initOnlyValidFromArray/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/pReduce/index.js
 
 
 
@@ -1706,129 +1968,161 @@ function stringFormatter(str, delimiter = '_') {
 
 
 
-;// ./lib/models/metadata/metadata.js
+;// ./lib/helpers/stringFormatter/index.js
 
 
 
-const DELIMITER = '_'
 
-class Metadata extends KeyValueObject {
-  static init(options = {}) {
-    if (options instanceof this) {
-      return options
-    }
-    const instance = new this({
-      ...options,
-      key: stringFormatter(options.key, DELIMITER),
-    })
-    return instance.isValid ? instance : null
+;// ./lib/helpers/stringHelper/stringHelper.js
+function baseXEncode(num, base = 34) {
+  const charset = getBaseCharset(base)
+  return encode(num, charset)
+}
+
+function encode(int, charset) {
+  const { byCode } = charset
+  if (int === 0) {
+    return byCode[0]
   }
-  static get _classname() {
-    return 'Metadata'
+
+  let res = ''
+  const max = charset.length
+  while (int > 0) {
+    res = byCode[int % max] + res
+    int = Math.floor(int / max)
   }
+  return res
+}
 
-  static merge(toArr, fromArr) {
-    (fromArr || []).map((from) => {
-      const found = toArr.find((to) => {
-        return metadata_isSame(to.key, from.key)
-      })
-      if (found) {
-        found.value = (found.value || []).concat(from.value)
-      } else {
-        toArr.push(from)
+function getBaseCharset(base) {
+  let charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZ'
+  if (base === 58) {
+    charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz'
+  }
+  return indexCharset(charset)
+}
+
+function indexCharset(str) {
+  const byCode = {}
+  const byChar = {}
+  const { length } = str
+  let char
+  for (let i = 0; i < length; i++) {
+    char = str[i]
+    byCode[i] = char
+    byChar[char] = i;
+  }
+  return { byCode, byChar, length }
+}
+
+function isSame(str1, str2) {
+  if (typeof str1 !== 'string' || typeof str2 !== 'string') {
+    return false
+  }
+  return str1.trim().toUpperCase() === str2.trim().toUpperCase()
+}
+
+function randomString({ len = 16, pattern = 'a1' } = {}) {
+  const A = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+  const a = 'abcdefghijklmnopqrstuvwxyz'
+  const num = '1234567890'
+  const mark = '~!@#$%^&*_+-='
+  let str = ''
+  if (pattern.includes('A')) {
+    str += A
+  }
+  if (pattern.includes('a')) {
+    str += a
+  }
+  if (pattern.includes('1')) {
+    str += num
+  }
+  if (pattern.includes('#')) {
+    str += mark
+  }
+  const chars = [...str]
+  return [...Array(len)].map(i => {
+    return chars[(Math.random() * chars.length) | 0]
+  }).join``
+}
+
+function reverse(str) {
+  const _str = (typeof str !== 'string') ? str.toString() : str
+  const splitString = _str.split('')
+  const reverseArray = splitString.reverse()
+  return reverseArray.join('')
+}
+
+function setCode(base = 34) {
+  const now = (new Date()).valueOf()
+  const random = randomString({
+    len: 8,
+    pattern: '1'
+  })
+  const str = reverse(`${now}${random}`)
+  // const str = `${now}${random}`
+  return baseXEncode(str, base)
+}
+
+function toCamelCase(str) {
+  if (!str) return ''
+  return str
+    .trim()
+    .split(/\s+/)
+    .map((word, index) => {
+      if (!word) return ''
+      if (index === 0) {
+        return word.toLowerCase()
       }
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
     })
-    return toArr
-  }
-  static sameKey(item, key) {
-    return metadata_isSame(item.key, key)
-  }
+    .join('')
 }
 
-function metadata_isSame(key1, key2) {
-  return stringFormatter(key1, DELIMITER) === stringFormatter(key2, DELIMITER)
+const stringHelper = {
+  isSame,
+  setCode,
+  toCamelCase,
 }
 
 
 
-;// ./lib/models/metadata/index.js
+;// ./lib/helpers/stringHelper/index.js
 
 
 
 
-;// ./lib/models/qMeta/qMeta.js
+;// ./lib/helpers/index.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) {
+
+;// ./lib/models/apiResponse/index.js
+
+
+
+
+
+;// ./lib/models/keyValueObject/keyValueObject.js
+class KeyValueObject {
+  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
+    this.key = options.key || null
+    this.value = (typeof options.value !== 'undefined') ? options.value : ''
   }
+
+  // Class methods
   static init(options = {}) {
     if (options instanceof this) {
       return options
@@ -1836,532 +2130,484 @@ class Repo {
     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 'Repo'
+    return 'KeyValueObject'
   }
   static get _superclass() {
-    return 'Repo'
+    return 'KeyValueObject'
   }
 
-  get _classname() {
-    return 'Repo'
+  static addItem(arr, key, value) {
+    arr.push(this.init({ key, value }))
   }
-
-  get _superclass() {
-    return 'Repo'
+  static addRecord(arr = [], key, value) {
+    if (!this.hasKeyValue(arr, key, value)) {
+      arr.push(this.init({ key, value }))
+    }
+    return arr
   }
-
-  get isValid() {
-    return this.model
-      && (typeof this.model.deleteOne === 'function')
-      && (typeof this.model.findAll === 'function')
-      && (typeof this.model.saveOne === 'function')
+  static appendRecord(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
+      }
+      return item
+    })
   }
-
-  get queryOptions() {
-    return {
-      ...this._sharedOptions,
-      ...this._queryOptions,
-    }
+  static appendValueArray(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
+      }
+      return item
+    })
   }
-
-  get saveOptions() {
-    return {
-      ...this._sharedOptions,
-      ...this._saveOptions,
-    }
+  static foundByKey(arr = [], key) {
+    const found = arr.find((m) => {
+      return this.sameKey(m, key)
+    })
+    return found || null
   }
-
-  init(options) {
-    if (this._Class && typeof this._Class.init === 'function') {
-      return this._Class.init(options)
+  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) {
+    return this.foundValueByKey(arr, key)
+  }
+  static getValueByKeyFromArray(arr = [], key) {
+    if (arr.length === 0) {
+      return null
     }
-    return options
+    const firstArr = arr.shift()
+    const found = firstArr.find((i) => {
+      return this.sameKey(i, key)
+    })
+    if (found && found.value) {
+      return found.value
+    }
+    return this.getValueByKeyFromArray(arr, key)
   }
-
-  async deleteOne({ id }) {
-    try {
-      const result = await this.model.deleteOne({ _id: id })
-      return {
-        ...result, // { message: 'ok', total }
-        isNew: false,
-        data: []
+  static getValuesByKey(arr = [], key) {
+    return arr.reduce((acc, item) => {
+      if (this.sameKey(item, key)) {
+        acc.push(item.value)
       }
-    } catch (err) {
-      throw err
+      return acc
+    }, [])
+  }
+  static hasKeyValue(arr = [], key, value) {
+    if (typeof value === 'undefined') {
+      return arr.filter((item) => this.sameKey(item, key)).length > 0
     }
+    return arr.filter((item) => (this.sameKey(item, key) && _isSame(item.value, value))).length > 0
   }
-
-  // systemLog is optional
-  findAll({ query, systemLog }) {
-    const log = _makeLog({
-      systemLog,
-      label: 'REPO_READ',
-      message: `fn ${this._classname}.prototype.findAll`,
-      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
-    })
-    return new Promise((resolve, reject) => {
-      this.model.findAll(query, this.queryOptions, (err, data, total) => {
-        if (err) {
-          log({ level: 'warn', output: err.toString() })
-          reject(err)
-        } else {
-          const result = {
-            isNew: false,
-            data,
-            total: total || data.length
-          }
-          log({ level: 'info', output: { ...result } })
-          resolve(result)
-        }
-      })
-    })
+  static insertOrUpdateRecord(arr = [], key, value) {
+    let copy = [...arr]
+    if (!this.hasKeyValue(arr, key)) {
+      copy.push(this.init({ key, value }))
+    } else {
+      copy = this.updateRecord(arr, key, value)
+    }
+    return copy
   }
-
-  findOne({ query, systemLog }) {
-    const log = _makeLog({
-      systemLog,
-      label: 'REPO_READ',
-      message: `fn ${this._classname}.prototype.findOne`,
-      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
-    })
-    return new Promise((resolve, reject) => {
-      this.model.findAll(query, this.queryOptions, (err, data) => {
-        if (err) {
-          reject(err)
-        } else if (data.length === 1) {
-          const result = {
-            isNew: false,
-            data,
-            total: 1
-          }
-          log({ level: 'info', output: { ...result } })
-          resolve(result)
-        } else if (data.length === 0) {
-          reject(new Error('record not found'))
-        } else {
-          reject(new Error('more than one is found'))
-        }
+  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)
+      }
     })
-      .catch((err) => {
-        log({ level: 'warn', output: err.toString() })
-        throw err
-      })
+    return toArr
   }
-
-  saveAll({ docs, systemLog }) {
-    let isNew
-    const log = _makeLog({
-      systemLog,
-      label: 'REPO_WRITE',
-      message: `fn ${this._classname}.prototype.saveAll`,
-      input: [{ docs: [...docs], systemLog: { ...systemLog } }]
-    })
-    const promise = typeof this.model.saveAll === 'function'
-      ? this.model.saveAll({ docs })
-      : 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
-      }))
-    return promise.then((savedData) => {
-      if (savedData.length !== 1) isNew = null
-      const result = {
-        data: savedData,
-        isNew,
-        total: savedData.length
+  static removeByKey(arr, key) {
+    return arr.reduce((acc, item) => {
+      if (!this.sameKey(item, key)) {
+        acc.push(item)
       }
-      log({ level: 'info', output: { ...result } })
-      return result
-    }).catch((err) => {
-      log({ level: 'warn', output: err.toString() })
-      throw err
-    })
+      return acc
+    }, [])
   }
-
-  saveOne({ doc, systemLog }) {
-    const log = _makeLog({
-      systemLog,
-      label: 'REPO_WRITE',
-      message: `fn ${this._classname}.prototype.saveOne`,
-      input: [{ doc: { ...doc }, systemLog: { ...systemLog } }]
-    })
-    return new Promise((resolve, reject) => {
-      this.model.saveOne(doc, this.saveOptions, (err, result) => {
-        if (err) {
-          log({ level: 'warn', output: err.toString() })
-          reject(err)
-        } else {
-          log({ level: 'info', output: { ...result } })
-          resolve(result)
+  static sameKey(item, key) {
+    return _isSame(item.key, key)
+  }
+  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 (this.sameKey(item, key)) {
+        return {
+          ...item,
+          value
         }
-      })
+      }
+      return item
     })
   }
-}
-
-function _makeLog({ systemLog, label, message: message1, input } = {}) {
-  return ({ level, messgae: massage2, output } = {}) => {
-    if (systemLog && systemLog.systemLogHelper) {
-      systemLog.systemLogHelper.log({
-        batchId: systemLog.batchId,
-        label,
-        level,
-        message: massage2 || message1,
-        data: {
-          payload: {
-            input,
-            output
-          }
-        }
+  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
+  }
 
-;// ./lib/models/repo/index.js
+  get toObject() {
+    const obj = {}
+    if (this.isValid) {
+      obj[this.key] = this.value
+    }
+    return obj
+  }
+}
 
+function _isSame(key1, key2) {
+  return key1 === key2
+}
 
 
 
-;// ./lib/models/service/service.js
+;// ./lib/models/keyValueObject/index.js
 
 
 
-class Service {
-  constructor({ repo }) {
-    this.repo = repo
-  }
 
-  static get _classname() {
-    return 'Service'
-  }
-  static get _superclass() {
-    return 'Service'
-  }
+;// ./lib/models/metadata/metadata.js
 
-  deleteOne({ id }) {
-    return this.repo.deleteOne({ id })
-      .catch(() => {
-        throw new Error(`Not found for query: ${id}`)
-      })
-  }
 
-  async findAll({ query = {}, systemLog } = {}) {
-    const result = await this.repo.findAll({ query, systemLog })
-    return makeApiResponse({
-      repo: this.repo,
-      result
-    })
-  }
 
-  async findOne({ query = {}, systemLog } = {}) {
-    const result = await this.repo.findOne({ query, systemLog })
-    return makeApiResponse({
-      repo: this.repo,
-      result
-    })
-  }
+const DELIMITER = '_'
 
-  init(options) {
-    return this.repo.init(options)
-  }
-  initFromArray(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.map((a) => this.init(a))
+class Metadata extends KeyValueObject {
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
     }
-    return []
+    const instance = new this({
+      ...options,
+      key: stringFormatter(options.key, DELIMITER),
+    })
+    return instance.isValid ? instance : null
   }
-  initOnlyValidFromArray(arr = []) {
-    return this.initFromArray(arr).filter((i) => i)
+  static get _classname() {
+    return 'Metadata'
   }
 
-  async saveAll({ docs = [], systemLog } = {}) {
-    const copies = docs.map((doc) => {
-      return this.init(doc)
-    })
-    const result = await this.repo.saveAll({ docs: copies, systemLog })
-    return makeApiResponse({
-      repo: this.repo,
-      result
+  static merge(toArr, fromArr) {
+    (fromArr || []).map((from) => {
+      const found = toArr.find((to) => {
+        return metadata_isSame(to.key, from.key)
+      })
+      if (found) {
+        found.value = (found.value || []).concat(from.value)
+      } else {
+        toArr.push(from)
+      }
     })
+    return toArr
   }
-
-  async saveOne({ doc = {}, systemLog } = {}) {
-    const copy = this.init(doc)
-    if (copy) {
-      const result = await this.repo.saveOne({ doc: copy, systemLog })
-      return makeApiResponse({
-        repo: this.repo,
-        result
-      })
-    }
-    return {
-      isNew: null,
-      data: [],
-      err: new Error('doc is not a valid instance')
-    }
+  static sameKey(item, key) {
+    return metadata_isSame(item.key, key)
   }
 }
 
-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 })
+function metadata_isSame(key1, key2) {
+  return stringFormatter(key1, DELIMITER) === stringFormatter(key2, DELIMITER)
 }
 
 
 
-;// ./lib/models/service/index.js
+;// ./lib/models/metadata/index.js
 
 
 
 
-;// ./lib/models/uniqueKeyGenerator/uniqueKeyGenerator.js
+;// ./lib/models/qMeta/qMeta.js
 
 
-class UniqueKeyGenerator {
+const updateAllowedProps = [
+  'attributes',
+  'ref'
+]
+
+class QMeta {
+  constructor(options = {}) {
+    options = options || {}
+    this.attributes = KeyValueObject.initOnlyValidFromArray(options.attributes)
+    this.ref = options.ref || {}
+  }
+
   static get _classname() {
-    return 'UniqueKeyGenerator'
+    return 'QMeta'
   }
   static get _superclass() {
-    return 'UniqueKeyGenerator'
+    return 'QMeta'
   }
-  static makeFormatter({ fieldName, format, options }) {
-    switch (format) {
-      case 'set_code':
-        return _makeSetCode(fieldName, options)
-      default:
-        return _makeSetCode(fieldName, options)
+
+  // Class methods
+  static init(options = {}) {
+    if (options instanceof QMeta) {
+      return options
     }
+    return new QMeta(options)
   }
-  static makeGenerator(arr) {
-    const fns = arr.map((item) => this.makeFormatter(item))
-    return async (obj) => {
-      const output = await pReduce(fns, async (acc, fn) => {
-        const _obj = await fn(obj)
-        return Object.assign(acc, _obj)
-      }, obj)
-      return output
+
+  // instance methods
+  addAttribute(obj) {
+    const kvObject = KeyValueObject.init(obj)
+    if (!kvObject) {
+      throw new Error('invalid meta attribute')
     }
+    this.attributes.push(kvObject)
+    return this
   }
-}
 
-function _makeSetCode(fieldName, options) {
-  return async (obj = {}) => {
-    if (obj[fieldName]) {
-      return {}
-    }
-    return {
-      [fieldName]: stringHelper.setCode()
-    }
+  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/uniqueKeyGenerator/index.js
-
-
-
-
-;// ./lib/models/index.js
-
-
-
-
+;// ./lib/models/qMeta/index.js
 
 
 
 
+;// ./lib/models/repo/index.js
 
-;// ./lib/helpers/generalPost/generalPost.js
 
 
 
+;// ./lib/models/service/index.js
 
-async function generalPost({ body = {}, GeneralModel, UniqueKeyGenerator, resourceInfo }) {
-  const { resources, data, globalShared = {}, shared = {}, relationship = {} } = body
-  const _resourceInfo = resourceInfo || body.resourceInfo
-  _attachShared(data, globalShared, shared)
-  const obj = await pReduce(resources, async (acc, resource) => {
-    const service = _makeService(resource, _resourceInfo, UniqueKeyGenerator, GeneralModel)
-    _createRelationship(data, relationship[resource], acc)
-    const _data = data[resource]
-    const result = await service.saveAll({ docs: [].concat(_data) })
-    acc[resource] = Array.isArray(_data) ? result._data : result._data[0]
-    return acc
-  }, {})
-  return obj
-}
 
-function _attachShared(data, globalShared = {}, shared = {}) {
-  Object.keys(shared).forEach((key) => {
-    const _data = data[key]
-    data[key] = objectHelper.merge({}, _data, globalShared, shared[key] || {})
-  })
-}
 
-function _createRelationship(data, relationship = {}, object) {
-  Object.keys(relationship).forEach((key) => {
-    const path = relationship[key]
-    const val = objectHelper.get(object, path)
-    objectHelper.set(data, key, val)
-  })
-}
 
-function _makeService(resource, resourceInfo, UniqueKeyGenerator, GeneralModel) {
-  const { collectionName, fields } = resourceInfo[resource]
-  const uniqueKeyGenerator = UniqueKeyGenerator.makeGenerator(fields)
-  const model = new GeneralModel({ collectionName, uniqueKeyGenerator })
-  return makeService({
-    repo: new Repo({ model })
-  })
-}
+;// ./lib/models/trackedEntity/trackedEntity.js
 
 
+class TrackedEntity {
+  constructor(options = {}, { trackFlat = false } = {}) {
+    const timestamp = Date.now()
+    const _tracking = {
+      active: options.active ?? true,
+      created: options.created ?? timestamp,
+      creator: options.creator ?? '',
+      deleted: options.deleted ?? false,
+      modified: options.modified ?? timestamp,
+      owner: options.owner ?? '',
+    }
 
-;// ./lib/helpers/generalPost/index.js
+    if (trackFlat) {
+      Object.assign(this, _tracking)
+    } else {
+      this.meta = { ..._tracking, ...options.meta }
+    }
+  }
 
+  // Class methods
+  static get _classname() {
+    return 'TrackedEntity'
+  }
+  static get _superclass() {
+    return 'TrackedEntity'
+  }
 
+  static init(options = {}) {
+    return init(this, options)
+  }
+  static initFromArray(arr = []) {
+    return initFromArray(this, arr)
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return initOnlyValidFromArray(this, arr)
+  }
+  static nest(entity) {
+    const { active, created, creator, deleted, modified, owner, ...rest } = entity
+    return { ...rest, meta: { active, created, creator, deleted, modified, owner } }
+  }
 
+  // getters
+  get isValid() {
+    return !!this
+  }
 
-;// ./lib/helpers/padZeros/padZeros.js
-function padZeros(num, minLength = 6) {
-  num = num.toString()
-  if (num.length < minLength) {
-    return padZeros('0' + num, minLength)
+  setModified() {
+    const timestamp = Date.now()
+    if (this.meta) {
+      this.meta.modified = timestamp
+    } else {
+      this.modified = timestamp
+    }
   }
-  return num
 }
 
+;// ./lib/models/trackedEntity/index.js
 
+ // Explicit named export (optional)
 
-;// ./lib/helpers/padZeros/index.js
-
-
-
-
-;// ./lib/helpers/pReduce/index.js
-
-
-
-
-;// ./lib/helpers/stringFormatter/index.js
+;// ./lib/models/tenantAwareEntity/tenantAwareEntity.js
 
 
+class TenantAwareEntity extends TrackedEntity {
+  constructor(options = {}) {
+    options = options || {}
 
+    /**
+     * instead of throw error, we choose to implement the isValid checking
+     */
+    // if (!options.tenantCode) {
+    //   throw new Error('tenantCode required')
+    // }
 
-;// ./lib/helpers/stringHelper/stringHelper.js
-function baseXEncode(num, base = 34) {
-  const charset = getBaseCharset(base)
-  return encode(num, charset)
-}
+    super(options)
 
-function encode(int, charset) {
-  let byCode = charset.byCode;
-  if (int === 0) {
-      return byCode[0];
+    this._tenant = options._tenant
+    this.tenantCode = options.tenantCode // Required for multi-tenancy
   }
 
-  var res = "",
-      max = charset.length;
-  while (int > 0) {
-      res = byCode[int % max] + res;
-      int = Math.floor(int / max);
+  // Class methods
+  static get _classname() {
+    return 'TenantAwareEntity'
   }
-  return res;
-}
-
-function getBaseCharset(base) {
-  let charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZ'
-  if (base === 58) {
-    charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz'
+  static get _superclass() {
+    return 'TenantAwareEntity'
   }
-  return indexCharset(charset)
-}
 
-function indexCharset(str) {
-  var byCode = {},
-      byChar = {},
-      length = str.length,
-      i, char;
-  for (i = 0; i < length; i++) {
-      char = str[i];
-      byCode[i] = char;
-      byChar[char] = i;
+  // getters
+  get isValid() {
+    return super.isValid && !!this.tenantCode // Required for multi-tenancy
   }
-  return { byCode: byCode, byChar: byChar, length: length };
 }
 
-function randomString({ len = 16, pattern = 'a1' } = {}) {
-  const A = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-  const a = 'abcdefghijklmnopqrstuvwxyz'
-  const num = '1234567890'
-  const mark = '~!@#$%^&*_+-='
-  let str = ''
-  if (pattern.includes('A')) {
-    str += A
+;// ./lib/models/tenantAwareEntity/index.js
+
+
+
+;// ./lib/models/uniqueKeyGenerator/uniqueKeyGenerator.js
+
+
+class UniqueKeyGenerator {
+  static get _classname() {
+    return 'UniqueKeyGenerator'
   }
-  if (pattern.includes('a')) {
-    str += a
+  static get _superclass() {
+    return 'UniqueKeyGenerator'
   }
-  if (pattern.includes('1')) {
-    str += num
+  static makeFormatter({ fieldName, format, options }) {
+    switch (format) {
+      case 'set_code':
+        return _makeSetCode(fieldName, options)
+      default:
+        return _makeSetCode(fieldName, options)
+    }
   }
-  if (pattern.includes('#')) {
-    str += mark
+  static makeGenerator(arr) {
+    const fns = arr.map((item) => this.makeFormatter(item))
+    return async (obj) => {
+      const output = await pReduce(fns, async (acc, fn) => {
+        const _obj = await fn(obj)
+        return Object.assign(acc, _obj)
+      }, obj)
+      return output
+    }
   }
-  const chars = [...str]
-  return [...Array(len)].map(i => {
-    return chars[(Math.random() * chars.length) | 0]
-  }).join``
 }
 
-function reverse(str) {
-  if (typeof str !== 'string') {
-    str = str.toString()
+function _makeSetCode(fieldName, options) {
+  return async (obj = {}) => {
+    if (obj[fieldName]) {
+      return {}
+    }
+    return {
+      [fieldName]: stringHelper.setCode()
+    }
   }
-  const splitString = str.split('')
-  const reverseArray = splitString.reverse()
-  return reverseArray.join('')
-}
-
-function setCode(base = 34) {
-  const now = (new Date()).valueOf()
-  const random = randomString({
-    len: 8,
-    pattern: '1'
-  })
-  const str = reverse(`${now}${random}`)
-  // const str = `${now}${random}`
-  return baseXEncode(str, base)
 }
 
-const stringHelper = {
-  setCode
-}
-
-
-;// ./lib/helpers/stringHelper/index.js
 
 
+;// ./lib/models/uniqueKeyGenerator/index.js
 
 
 
-;// ./lib/helpers/index.js
 
+;// ./lib/models/index.js
 
 
 
@@ -2380,25 +2626,7 @@ const stringHelper = {
 ;// ./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__TemplateCompiler = __webpack_exports__.Mg;
-var __webpack_exports__UniqueKeyGenerator = __webpack_exports__._x;
-var __webpack_exports__concatStringByArray = __webpack_exports__.yl;
-var __webpack_exports__convertString = __webpack_exports__.l0;
-var __webpack_exports__formatDate = __webpack_exports__.Yq;
-var __webpack_exports__generalPost = __webpack_exports__.zn;
-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__objectHelper = __webpack_exports__.UI;
-var __webpack_exports__pReduce = __webpack_exports__.d;
-var __webpack_exports__padZeros = __webpack_exports__.Lv;
-var __webpack_exports__stringFormatter = __webpack_exports__.Qy;
-var __webpack_exports__stringHelper = __webpack_exports__.yO;
-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__TemplateCompiler as TemplateCompiler, __webpack_exports__UniqueKeyGenerator as UniqueKeyGenerator, __webpack_exports__concatStringByArray as concatStringByArray, __webpack_exports__convertString as convertString, __webpack_exports__formatDate as formatDate, __webpack_exports__generalPost as generalPost, __webpack_exports__getValidation as getValidation, __webpack_exports__getValueByKeys as getValueByKeys, __webpack_exports__makeApiResponse as makeApiResponse, __webpack_exports__makeService as makeService, __webpack_exports__objectHelper as objectHelper, __webpack_exports__pReduce as pReduce, __webpack_exports__padZeros as padZeros, __webpack_exports__stringFormatter as stringFormatter, __webpack_exports__stringHelper as stringHelper };
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});