@questwork/q-utilities 0.1.13 → 0.1.14

package/dist/q-utilities.esm.js

@@ -0,0 +1,2824 @@
+
+;// ./lib/helpers/authorize/authorize.js
+function authorize({ allowOwner, query = {}, required, user }) {
+  if (!user) {
+    throw new Error('Require login.')
+  }
+  if (!user.permission) {
+    throw new Error('You do not have any permission.')
+  }
+  const scopes = user.permission.getScopes(required || {})
+  if (!scopes || scopes.length === 0) {
+    throw new Error('You are not allowed in this scope.')
+  }
+  if (!scopes.includes('*')) {
+    query.tenantCode = user.tenantCode
+  }
+  if (!scopes.includes('TENANT')) {
+    query.eventShortCode = user.eventShortCode
+  }
+  if (!scopes.includes('EVENT')) {
+    query.eventRegistrationCode = user.eventRegistrationCode
+  }
+  if (allowOwner) {
+    query.__ALLOW_OWNER = true
+  }
+  // not good, just use it as example
+  if (user.hasExcludedFields) {
+    query.__EXCLUDED_FIELDS = user.getExcludedFields(required)
+  }
+  query.__LOGIN_SUBJECT_CODE = user.loginSubjectCode
+  return query
+}
+
+;// ./lib/helpers/authorize/index.js
+
+
+;// ./lib/helpers/getValidation/getValidation.js
+function getValidation(rule, data, getDataByKey, KeyValueObject) {
+  if (!rule) {
+    return true
+  }
+  if (typeof getDataByKey !== 'function' || (KeyValueObject && 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 '$intervalTimeGt': {
+      const now = new Date().getTime()
+      const timestamp = new Date(rowValue).getTime()
+      return (now - timestamp) > value['$intervalTimeGt']
+    }
+    case '$intervalTimeLt': {
+      const now = new Date().getTime()
+      const timestamp = new Date(rowValue).getTime()
+      return (now - timestamp) < value['$intervalTimeLt']
+    }
+    case '$isToday': {
+      const currentDate = new Date()
+      const start = currentDate.setHours(0,0,0,0)
+      const end = currentDate.setHours(23,59,59,59)
+      const dateValue = new Date(rowValue).getTime()
+      return (start <= dateValue && end >= dateValue) === value['$isToday']
+    }
+    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/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/getValueByKeys/getValueByKeys.js
+// keys can be array or object or string
+function getValueByKeys_getValueByKeys(keys, data) {
+  let _keys = keys
+  let _data = data
+  if (typeof keys === 'string') {
+    _keys = _keys.split('.')
+  }
+  if (!Array.isArray(keys) && typeof keys === 'object') {
+    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_getValueByKeys(_keys, _data[firstKey])
+  }
+  if (_data && firstKey) {
+    return _data[firstKey]
+  }
+  return _data
+
+}
+/* harmony default export */ const getValueByKeys = ({
+  getValueByKeys: getValueByKeys_getValueByKeys
+});
+
+
+;// ./lib/helpers/getValueByKeys/index.js
+
+
+;// ./lib/models/templateCompiler/templateCompilerException.js
+const TEMPLATE_COMPILER_EXCEPTION_TYPE = {
+  argumentEmptyException: 'Argument is empty',
+  argumentFormatException: 'Incorrect number or format of argument',
+  invalidFuntionException: 'Function Name is invalid',
+  invalidRegExpException: 'Invalid regular expression',
+  isNotAFunctionException: 'Is not a function',
+  notExistException: 'Key does not exist',
+  resultEmptyException: 'Result is empty',
+  resultMoreThanOneException: 'More than one result'
+}
+
+class TemplateCompilerException extends Error {
+  constructor(message) {
+    super(message)
+    this.message = message
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/constants.js
+const _EMPTY = '_EMPTY'
+const _FN_NAMES = [
+  'concatIf',
+  'divide',
+  'eq',
+  'exec',
+  'filterAll',
+  'filterOne',
+  'formatDate',
+  'get',
+  'gt',
+  'gte',
+  'isEmpty',
+  'isNotEmpty',
+  'join',
+  'lt',
+  'lte',
+  'map',
+  'neq',
+  'removeHtml',
+  'toLowerCase',
+  'toUpperCase',
+]
+const _HIDE = '_HIDE'
+const _NOT_EMPTY = '_NOT_EMPTY'
+const _SELF = '_SELF'
+const TAGS_EJS = ['<%=', '%>']
+const TAGS_HANDLEBAR = ['{{', '}}']
+
+
+
+;// ./lib/models/templateCompiler/helpers/_concatIf.js
+
+
+
+
+function _concatIf(data, args) {
+  if (typeof data !== 'string') {
+    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string :${data.join(', ')}`)
+  }
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  const [condition, success, failover] = args
+  const validConditions = [_EMPTY, _NOT_EMPTY]
+  if (validConditions.includes(condition) || success.length !== 2) {
+    throw new TemplateCompilerException(`concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException}: ${condition}, ${success}`)
+  }
+  if (data === '' && failover.includes(_HIDE)) {
+    return ''
+  }
+  if (data !== '' && (data !== null || data !== undefined) && failover.includes(_HIDE)) {
+    return `${success[0]}${data}${success[success.length - 1]}`
+  }
+  return failover
+}
+
+
+
+;// ./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
+
+
+
+
+function _eq(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`eq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data === expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_exec.js
+function _exec(data, args) {
+  try {
+    const [methodName, ..._args] = args
+    return data[methodName](..._args)
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_filterAll.js
+
+
+
+// const DELIMITER = '~~~'
+
+function _filterAll(data, args) {
+  try {
+    if (!Array.isArray(args) || args.length === 0) {
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
+    }
+    if (!Array.isArray(data) || data.length === 0) {
+      return []
+    }
+    if (typeof data[0] === 'object') {
+      return _existObject(data, args)
+    }
+    if (typeof data[0] === 'string' || typeof data[0] === 'number') {
+      return _exist(data, args)
+    }
+    return []
+  } catch (e) {
+    throw e
+  }
+}
+
+function _exist(data, args) {
+  const _args = args.flat()
+  return data.filter((e) => _args.some((arg) => _performOperation(arg, e)))
+}
+
+function _existObject(data, args) {
+  if (args.length === 1) {
+    const arg = args[0]
+    return data.filter((e) => {
+      if (arg.includes('.')) {
+        return getValueByKeys_getValueByKeys(arg.split('.'), e)
+      }
+      return Object.prototype.hasOwnProperty.call(e, arg)
+    })
+  }
+
+  if (args.length > 2) {
+    let res = data
+    for (let i = 0; i < args.length; i += 2) {
+      const group = [args[i], args[i + 1]]
+      res = _existObject(res, group)
+    }
+    return res
+  }
+
+  const [key, ..._argsArr] = args
+  const _args = _argsArr.flat()
+  return data.filter((e) => {
+    const value = key.includes('.') ? getValueByKeys_getValueByKeys(key.split('.'), e) : e[key]
+    return _args.some((arg) => _performOperation(arg, value))
+  })
+}
+
+function _performOperation(arg, value) {
+  // the arg is undefined
+  if (arg === undefined && value === undefined) return true
+
+  // the arg is null
+  if (arg === null && value === null) return true
+
+  // the arg is boolean
+  if (typeof arg === 'boolean') {
+    return arg === value
+  }
+
+  // the arg is blank or *: Blank => Empty, * => Not Empty
+  if (arg === '' || arg === '*') {
+    // null and undefined are not included in either case
+    if (value === null || value === undefined) {
+      return false
+    }
+    if (typeof value === 'string') {
+      return arg === '' ? value === '' : value !== ''
+    }
+    if (Array.isArray(value)) {
+      return arg === '' ? value.length === 0 : value.length !== 0
+    }
+    return arg !== ''
+  }
+
+  // the arg is alphabetic or number
+  if (_isPureStringOrNumber(arg)) {
+    return arg === value
+  }
+
+  // the arg is array of [] or [*]: [] => Empty, [*] => Not Empty
+  if (arg.startsWith('[') && arg.endsWith(']')) {
+    if (arg === '[]') {
+      return Array.isArray(value) && value.length === 0
+    }
+    if (arg === '[*]') {
+      return Array.isArray(value) && value.length !== 0
+    }
+    return false
+  }
+
+  // the arg is 'operator + string | number'
+  const { operator, value: argValue } = _splitOperator(arg)
+  if (!operator || (argValue !== 0 && !argValue)) {
+    return false
+  }
+  switch (operator) {
+    case '>':
+      return value > argValue
+    case '<':
+      return value < argValue
+    case '!=':
+      return value !== argValue
+    case '>=':
+      return value >= argValue
+    case '<=':
+      return value <= argValue
+    default:
+      return false
+  }
+}
+
+function _isPureStringOrNumber(input) {
+  if (typeof input === 'string') {
+    if (input.startsWith('[') && input.endsWith(']')) {
+      return false
+    }
+    if (/!=|>=|<=|>|</.test(input)) {
+      return false
+    }
+    return true
+  }
+  return !Number.isNaN(input)
+}
+
+function _splitOperator(str) {
+  const operators = ['!=', '>=', '<=', '>', '<']
+
+  const matchedOp = operators.find((op) => str.startsWith(op))
+  if (!matchedOp) return { operator: null, value: null }
+
+  const remaining = str.slice(matchedOp.length)
+
+  // '>Primary' or '<Primary' is invalid
+  if (/^[a-zA-Z]*$/.test(remaining) && matchedOp !== '!=') {
+    return { operator: null, value: null }
+  }
+
+  // if it is a number it is converted to a number
+  const value = (!Number.isNaN(parseFloat(remaining)) && !Number.isNaN(remaining)) ? Number(remaining) : remaining
+
+  return {
+    operator: matchedOp,
+    value
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_filterOne.js
+
+
+
+function _filterOne(data, args) {
+  try {
+    const list = _filterAll(data, args)
+    if (list.length === 1) {
+      return list[0]
+    }
+    if (list.length === 0) {
+      return null
+    }
+    throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.resultMoreThanOneException)
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_formatDate.js
+
+
+function _formatDate(timestamp, format) {
+  if (format.length === 0) {
+    throw new TemplateCompilerException(`_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: format parts must be not empty array`)
+  }
+
+  if (timestamp === null || timestamp === undefined) {
+    return null
+  }
+
+  const date = new Date(timestamp)
+
+  const partsMap = {
+    yyyy: String(date.getFullYear()),
+    mm: String(date.getMonth() + 1).padStart(2, '0'),
+    dd: String(date.getDate()).padStart(2, '0')
+  }
+
+  // Check for invalid format tokens
+  const validTokens = ['yyyy', 'mm', 'dd']
+  const invalidTokens = format.filter((part) => part.length > 1 && !validTokens.includes(part))
+
+  if (invalidTokens.length > 0) {
+    throw new TemplateCompilerException(
+      `_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the format type is not valid: ${format.join(', ')}`
+    )
+  }
+
+  // Build the formatted string using reduce
+  return format.reduce((result, part) => result + (partsMap[part] || part), '')
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_get.js
+
+
+function _get(data, key, failover = null) {
+  try {
+    if (key === null || (typeof key === 'undefined') || key === '') {
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
+    }
+    if (data === null) {
+      return null
+    }
+    if (key.includes('.')) {
+      const parts = key.split('.')
+      if (parts.length > 1) {
+        const first = parts.shift()
+        const remainingKey = parts.join('.')
+        if (typeof data[first] !== 'undefined') {
+          return _get(data[first], remainingKey, failover)
+        }
+        return _handleFailover(key, failover)
+      }
+    }
+    if (typeof data[key] !== 'undefined') {
+      return data[key]
+    }
+    return _handleFailover(key, failover)
+  } catch (e) {
+    throw e
+  }
+}
+
+function _handleFailover(key, failover) {
+  if (failover !== null) {
+    return failover
+  }
+  return null
+  // throw new TemplateCompilerException(`Key "${key}" does not exist and no failover`)
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_gt.js
+
+
+
+
+function _gt(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_gt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data > expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_gte.js
+
+
+
+
+function _gte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_gte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data >= expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_isEmpty.js
+
+
+
+
+function _isEmpty(data, args) {
+  if (args.length !== 2) {
+    throw new TemplateCompilerException(`_isEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  // if (data === null || (typeof data === 'undefined')) {
+  //   return null
+  // }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
+    return args[0]
+  }
+  return (data === '' || data === null || data === undefined || data.length === 0) ? args[0] : args[1]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_isNotEmpty.js
+
+
+
+
+function _isNotEmpty(data, args) {
+  if (args.length !== 2) {
+    throw new TemplateCompilerException(`_isNotEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  // if (data === null || (typeof data === 'undefined')) {
+  //   return null
+  // }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
+    return args[1]
+  }
+  if (Array.isArray(data) && data.length === 0) {
+    return args[1]
+  }
+  if (typeof data === 'string' && data === '') {
+    return args[1]
+  }
+  if (data === null || data === undefined) {
+    return args[1]
+  }
+  return args[0]
+}
+
+
+;// ./lib/models/templateCompiler/helpers/_join.js
+function _join(data, delimiter) {
+  try {
+    if (data.length === 0) return ''
+    if (data.length === 1) return _stringifyObject(data[0])
+    return data.map((item) => _stringifyObject(item)).join(delimiter)
+  } catch (e) {
+    throw e
+  }
+}
+
+function _stringifyObject(obj) {
+  return JSON.stringify(obj).replace(/"([^"]+)":/g, '$1: ').replace(/"([^"]+)"/g, '$1').replace(/,/g, ', ')
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_lt.js
+
+
+
+
+function _lt(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data < expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_lte.js
+
+
+
+
+function _lte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data <= expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_map.js
+
+
+
+function _map(data, args) {
+  try {
+    if (args.length === 0) {
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
+    }
+    if (data === null || (typeof data === 'undefined')) {
+      return null
+    }
+
+    const result = data.reduce((acc, item) => {
+      if (args.length === 1 && Array.isArray(args[0])) {
+        args = args[0]
+        acc.hasFormat = true
+      }
+      const list = args.map((key) => {
+        if (key.includes('.')) {
+          const parts = key.split('.')
+          const first = parts[0]
+          parts.shift()
+          const remainingKey = parts.join('.')
+          return _get(item[first], remainingKey)
+        }
+        if (typeof item[key] !== 'undefined') {
+          return item[key]
+        }
+        return null
+      })
+      if (acc.hasFormat) {
+        acc.content.push(list)
+      } else {
+        acc.content = acc.content.concat(list)
+      }
+      return acc
+    }, {
+      content: [],
+      hasFormat: false
+    })
+    return result.content
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_neq.js
+
+
+
+
+function _neq(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_neq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data !== expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_removeHtml.js
+
+
+function _removeHtml(html, args) {
+  if (html === null || html === undefined) {
+    return null
+  }
+  if (!Array.isArray(args)) {
+    throw new TemplateCompilerException(`_removeHtml: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: args parts must be array`)
+  }
+
+  return _htmlToPlainText(html, args[0])
+}
+
+function _htmlToPlainText(html, delimiter = '\n') {
+  if (typeof delimiter !== 'string') {
+    delimiter = '\n'; // Fallback to default if not a string
+  }
+
+  // First decode HTML entities and normalize whitespace
+  const decodedHtml = html
+    .replace(/&nbsp;/g, ' ')
+    .replace(/\s+/g, ' ');  // Collapse all whitespace to single spaces
+
+  // Process HTML tags
+  let text = decodedHtml
+    // Replace block tags with temporary marker (~~~)
+    .replace(/<\/?(p|div|h[1-6]|ul|ol|li|pre|section|article|table|tr|td|th)(\s[^>]*)?>/gi, '~~~')
+    // Replace <br> tags with temporary marker (~~~)
+    .replace(/<br\s*\/?>/gi, '~~~')
+    // Remove all other tags
+    .replace(/<[^>]+>/g, '')
+    // Convert markers to specified delimiter
+    .replace(/~~~+/g, delimiter)
+    // Trim and clean whitespace
+    .trim();
+
+  // Special handling for empty delimiter
+  if (delimiter === '') {
+    // Collapse all whitespace to single space
+    text = text.replace(/\s+/g, ' ');
+  } else {
+
+
+    // Collapse multiple delimiters to single
+    text = text.replace(new RegExp(`${escapeRegExp(delimiter)}+`, 'g'), delimiter);
+    // Remove leading/trailing delimiters
+    text = text.replace(new RegExp(`^${escapeRegExp(delimiter)}|${escapeRegExp(delimiter)}$`, 'g'), '');
+  }
+
+  return text;
+}
+
+
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_toLowerCase.js
+
+
+function _toLowerCase(data, args) {
+  if (args !== undefined) {
+    throw new TemplateCompilerException(`_toLowerCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
+    return null
+  }
+  return String(data).toLowerCase()
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_toUpperCase.js
+
+
+function _toUpperCase(data, args) {
+  if (typeof data !== 'string') {
+    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string: ${data}`)
+  }
+  if (args !== undefined) {
+    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the argument must be empty: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
+    return null
+  }
+  return String(data).toUpperCase()
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./lib/models/templateCompiler/templateCompiler.js
+
+
+
+
+class TemplateCompiler {
+  constructor(data) {
+    this.data = data
+  }
+  static init(options) {
+    return new this(options)
+  }
+  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 concatIf(data, args) {
+    return _concatIf(data, args)
+  }
+  static divide(data, args) {
+    return _divide(data, args)
+  }
+  static eq(data, args) {
+    return _eq(data, args)
+  }
+
+  static filterAll(data, args) {
+    return _filterAll(data, args)
+  }
+
+  static formatDate(data, args) {
+    return _formatDate(data, args)
+  }
+  static get(data, key, failover = null) {
+    return _get(data, key, failover)
+  }
+  static gt(data, args) {
+    return _gt(data, args)
+  }
+  static gte(data, args) {
+    return _gte(data, args)
+  }
+  static isEmpty(data, args) {
+    return _isEmpty(data, args)
+  }
+  static isNotEmpty(data, args) {
+    return _isNotEmpty(data, args)
+  }
+  static join(data, separator = '') {
+    return _join(data, separator)
+  }
+  static lt(data, args) {
+    return _lt(data, args)
+  }
+  static lte(data, args) {
+    return _lte(data, args)
+  }
+  static map(data, args = []) {
+    return _map(data, args)
+  }
+  static neq(data, args) {
+    return _neq(data, args)
+  }
+  static removeHtml(data, args) {
+    return _removeHtml(data, args)
+  }
+  static toLowerCase(data, args) {
+    return _toLowerCase(data, args)
+  }
+  static toUpperCase(data, args) {
+    return _toUpperCase(data, args)
+  }
+  static parseFunction(expression) {
+    return _parseFunction(expression, _FN_NAMES)
+  }
+  static parseParams(parameters) {
+    return _parseParams(parameters)
+  }
+
+  pipe(expression = '') {
+    this.delimiters = expression.substring(0, 2) === '{{' ? TAGS_HANDLEBAR : TAGS_EJS
+    const regex = new RegExp(`${this.delimiters[0]}\\s(.*?)\\s${this.delimiters[1]}`)
+    const match = expression.match(regex)
+    if (match !== null) {
+      try {
+        const functionList = _parseFunction(match[1], _FN_NAMES)
+        return functionList.reduce((acc, fn) => {
+          return _callFunction(acc, fn.name, fn.args)
+        }, this.data)
+      } catch (e) {
+        throw new TemplateCompilerException(`TemplateCompiler engine error: ${e.message}`)
+      }
+    }
+    throw new TemplateCompilerException(`TemplateCompiler engine error: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.invalidRegExpException}`)
+  }
+}
+
+function _parseFunction(expression, existFunctionNames) {
+  const regExp = new RegExp(/(\w+)\(([^)]*)\)/)
+  let parts
+  if (expression.includes('|')) {
+    parts = expression.split('|')
+  } else {
+    parts = [expression]
+  }
+  return parts.reduce((acc, part) => {
+    const match = part.match(regExp)
+    if (match !== null) {
+      const functionName = match[1]
+      const parameters = match[2]
+      const paramList = _parseParams(parameters)
+      if (existFunctionNames.includes(functionName)) {
+        acc.push({
+          name: functionName,
+          args: paramList
+        })
+      } else {
+        throw new TemplateCompilerException(`${functionName} is not a valid function`)
+      }
+    }
+    return acc
+  }, [])
+}
+
+function _parseParams(parameters) {
+  const _parameters = parameters.trim()
+  const regExp = new RegExp(/^[^\w\d\s]+$/)
+  const match = _parameters.match(regExp)
+  if (match !== null) {
+    return [_parameters.substring(1, _parameters.length - 1)]
+  }
+  if (_parameters.includes(',')) {
+    // 用正则表达式匹配逗号，但忽略方括号中的逗号
+    const parts = _splitIgnoringBrackets(_parameters)
+    return parts.map((part) => _parseSinglePart(part))
+  }
+  return [_parseSinglePart(_parameters)]
+}
+
+function _splitIgnoringBrackets(input) {
+  const regExp2 = new RegExp(/^\d+(\.\d+)?$/)
+  const regExp = new RegExp(/(?![^\[]*\])\s*,\s*/)
+  const parts = input.split(regExp)
+  return parts.map((part) => {
+    const _part = part.trim()
+    if (_part !== '' && !!_part.match(regExp2)) {
+      // 如果是数字，转换为 num 类型
+      return Number.isNaN(_part) ? _part : parseInt(_part, 10)
+    }
+    // 否则当作字符串处理
+    return _part
+  })
+}
+
+function _parseSinglePart(input) {
+  if (typeof input === 'string') {
+    if (input.startsWith('"') && input.endsWith('"')) {
+      // 去掉双引号，返回
+      return input.substring(1, input.length - 1)
+    }
+    if (input.startsWith("'") && input.endsWith("'")) {
+      // 去掉双引号，返回
+      return input.substring(1, input.length - 1)
+    }
+
+    const _input = _toBasicType(input)
+
+    if (typeof _input !== 'string') {
+      return _input
+    }
+
+    // 如果是一个列表形式（例如 ["p", "d"] 或 [p, d]）
+    if (_input.startsWith('[') && _input.endsWith(']')) {
+      const listContent = _input.substring(1, _input.length - 1).trim()
+      if (listContent !== '') {
+        return listContent.split(',').map((item) => {
+          return _toBasicType(item.trim())
+        })
+      }
+      return []
+    }
+    return input
+  }
+  return input
+}
+
+function _toBasicType(input) {
+  if (input.startsWith('"') && input.endsWith('"')) {
+    // 去掉双引号，返回
+    return input.substring(1, input.length - 1)
+  }
+  if (input.startsWith("'") && input.endsWith("'")) {
+    // 去掉双引号，返回
+    return input.substring(1, input.length - 1)
+  }
+  if (input === 'true') {
+    return true
+  }
+  if (input === 'false') {
+    return false
+  }
+  if (input === 'undefined') {
+    return undefined
+  }
+  if (input === 'null') {
+    return null
+  }
+  if (!Number.isNaN(input) && !Number.isNaN(Number.parseFloat(input))) {
+    return Number(input)
+  }
+  return input
+}
+
+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)
+        }
+        if (parameters.length === 2) {
+          failover = parameters[parameters.length - 1]
+        }
+        return _get(data, parameters[0], failover)
+      case 'gt':
+        return _gt(data, parameters)
+      case 'gte':
+        return _gte(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 'removeHtml':
+        return _removeHtml(data, parameters)
+      case 'toLowerCase':
+        return _toLowerCase(data)
+      case 'toUpperCase':
+        return _toUpperCase(data)
+      default:
+        throw new Error(`${functionName} is not a valid function`)
+    }
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/index.js
+
+
+
+
+;// ./lib/helpers/concatStringByArray/concatStringByArray.js
+
+
+
+
+
+function concatStringByArray(arrTemplate, data) {
+  return arrTemplate.reduce((acc, item) => {
+    const { type, value = '', restriction, template, format, showMinutes } = item
+    switch (type) {
+      case('label'): {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          acc += (value.toString())
+        }
+        break
+      }
+      case('value'): {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
+          acc += (_value.toString())
+        }
+        break 
+      }
+      case('array'): {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || []
+          acc += _value.reduce((_acc, item) => {
+            return _acc += concatStringByArray(template, item)
+          }, '')
+        }
+        break 
+      }
+      case('ellipsis'): {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          const { maxLength } = item
+          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
+          if (_value.length <= maxLength) {
+            acc += (_value.toString())
+          } else {
+            acc += `${_value.substr(0, maxLength)}...`
+          }
+        }
+        break 
+      }
+      case ('date'): {
+        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_getValueByKeys)) {
+          const templateCompiler = new TemplateCompiler({ data })
+          acc += templateCompiler.pipe(value)
+        }
+        break
+      }
+    }
+    return acc
+  }, '')
+}
+/* harmony default export */ const concatStringByArray_concatStringByArray = ({
+  concatStringByArray
+});
+
+
+
+;// ./lib/helpers/concatStringByArray/index.js
+
+
+;// ./lib/helpers/convertString/convertString.js
+
+
+function convertString(string, patternMatch = /\$\{(.+?)\}/g, value, getValueByKeys) {
+  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 })
+    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/objectHelper/objectHelper.js
+const objectHelper = {
+  get(obj, path) {
+    const parts = path.split('.')
+    return parts.reduce((acc, part) => {
+      if (part.endsWith('[]')) {
+        // 处理数组遍历
+        const key = part.slice(0, -2) // 去掉 '[]' 得到属性名
+        if (Array.isArray(acc[key])) {
+          return acc[key] // 返回整个数组
+        }
+        return [] // 如果不是数组，返回空数组
+      }
+      if (part.includes('[') && part.includes(']')) {
+        // 处理数组索引
+        const arrayMatch = part.match(/(\w+)\[(\d+)\]/)
+        if (arrayMatch) {
+          const key = arrayMatch[1]
+          const index = arrayMatch[2]
+          return acc && acc[key] && acc[key][index]
+        }
+      } else if (acc && Array.isArray(acc)) {
+        // 如果当前值是数组，提取每个对象的指定属性
+        return acc.map((item) => item[part])
+      } else {
+        // 处理普通属性
+        return acc && acc[part]
+      }
+    }, obj)
+  },
+  merge,
+  set(obj, path, value) {
+    const parts = path.split('.');
+    let current = obj;
+
+    // 处理所有中间部分
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      let key, index;
+
+      // 检查是否是数组索引格式，如key[0]
+      const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+      if (arrayMatch) {
+        key = arrayMatch[1];
+        index = parseInt(arrayMatch[2], 10);
+        // 确保当前层级的数组存在
+        if (!current[key] || !Array.isArray(current[key])) {
+          current[key] = [];
+        }
+        // 扩展数组到足够大
+        while (current[key].length <= index) {
+          current[key].push(undefined);
+        }
+        // 如果当前位置未定义或为null，初始化为对象
+        if (current[key][index] == null) {
+          current[key][index] = {};
+        }
+        current = current[key][index];
+      } else {
+        // 处理普通属性
+        if (!current[part]) {
+          current[part] = {};
+        }
+        current = current[part];
+      }
+    }
+
+    // 处理最后一部分
+    const lastPart = parts[parts.length - 1];
+    const arrayMatch = lastPart.match(/^(\w+)\[(\d+)\]$/);
+    if (arrayMatch) {
+      const key = arrayMatch[1];
+      const index = parseInt(arrayMatch[2], 10);
+      // 确保数组存在
+      if (!current[key] || !Array.isArray(current[key])) {
+        current[key] = [];
+      }
+      // 扩展数组到所需索引
+      while (current[key].length <= index) {
+        current[key].push(undefined);
+      }
+      current[key][index] = value;
+    } else {
+      current[lastPart] = value;
+    }
+  }
+}
+
+function merge(target, ...sources) {
+  if (!sources.length) return target
+
+  const source = sources.shift() // 取出第一个源对象
+
+  if (_isObject(target) && _isObject(source)) {
+    for (const key in source) {
+      if (_isObject(source[key])) {
+        if (!target[key]) {
+          // 如果目标对象没有该属性，创建一个空对象
+          target[key] = {}
+        }
+        // 递归合并
+        merge(target[key], source[key])
+      } else {
+        // 直接覆盖
+        target[key] = source[key]
+      }
+    }
+  }
+
+  // 继续合并剩余的源对象
+  return merge(target, ...sources)
+}
+
+function _isObject(obj) {
+  return obj && typeof obj === 'object' && !Array.isArray(obj)
+}
+
+
+
+;// ./lib/helpers/objectHelper/index.js
+
+
+
+
+;// ./lib/helpers/pReduce/pReduce.js
+async function pReduce(iterable, reducer, initialValue) {
+	return new Promise((resolve, reject) => {
+		const iterator = iterable[Symbol.iterator]()
+		let index = 0
+
+		const next = async total => {
+			const element = iterator.next()
+
+			if (element.done) {
+				resolve(total)
+				return
+			}
+
+			try {
+				const [resolvedTotal, resolvedValue] = await Promise.all([total, element.value])
+				next(reducer(resolvedTotal, resolvedValue, index++))
+			} catch (error) {
+				reject(error)
+			}
+		}
+
+		next(initialValue)
+	})
+}
+
+
+
+;// ./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 = {}) {
+    return init(this, options)
+  }
+  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
+    }
+  }
+
+  // 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)
+        }
+      })
+    })
+  }
+
+  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'))
+        }
+      })
+    })
+      .catch((err) => {
+        log({ level: 'warn', output: err.toString() })
+        throw err
+      })
+  }
+
+  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
+    })
+  }
+
+  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)
+        }
+      })
+    })
+  }
+}
+
+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
+          }
+        }
+      })
+    }
+  }
+}
+
+
+
+;// ./lib/models/repo/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/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 = {}, 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
+    })
+  }
+
+  init(options) {
+    return this.repo.init(options)
+  }
+  initFromArray(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.map((a) => this.init(a))
+    }
+    return []
+  }
+  initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+
+  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
+    })
+  }
+
+  // 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 {
+      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/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]
+    if (Array.isArray(_data)) {
+      data[key] = _data.map((_dataItem) => {
+        return objectHelper.merge({}, _dataItem, globalShared, shared[key] || {})
+      })
+    } else {
+      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 !== false ? instance : null
+  } catch (e) {
+    console.log(`init failed for class: ${_class._classname || 'no _classname'}`, e)
+    return null
+  }
+}
+
+;// ./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/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
+
+
+
+
+;// ./lib/helpers/stringFormatter/stringFormatter.js
+function stringFormatter(str, delimiter = '_') {
+  if (str === null || typeof str === 'undefined' || typeof str.toString === 'undefined') {
+    return null
+  }
+  return str.toString()
+    .trim()
+    .toUpperCase()
+    .replace('-', delimiter)
+    .replace(' ', delimiter)
+}
+
+
+
+;// ./lib/helpers/stringFormatter/index.js
+
+
+
+
+;// ./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]
+  }
+
+  let res = ''
+  const max = charset.length
+  while (int > 0) {
+    res = byCode[int % max] + res
+    int = Math.floor(int / max)
+  }
+  return res
+}
+
+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()
+    })
+    .join('')
+}
+
+const stringHelper = {
+  isSame,
+  setCode,
+  toCamelCase,
+}
+
+
+
+;// ./lib/helpers/stringHelper/index.js
+
+
+
+
+;// ./lib/helpers/trackingPlugin/trackingPlugin.js
+function trackingPlugin(schema, options) {
+  // Add meta fields
+  schema.add({
+    meta: {
+      active: { type: Boolean, default: true },
+      created: { type: Number },
+      creator: { type: String },
+      deleted: { type: Boolean, default: false },
+      modified: { type: Number },
+      owner: { type: String },
+    }
+  })
+
+  // Auto-update hook
+  schema.pre('save', function(next) {
+    this.meta.modified = Date.now()
+    next()
+  })
+
+  // Optional: Add helper methods
+  // schema.methods.touch = function(userId) {
+  //   this.meta.updatedAt = new Date()
+  //   this.meta.updatedBy = userId
+  // }
+}
+
+;// ./lib/helpers/trackingPlugin/index.js
+
+
+;// ./lib/helpers/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./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(this.init({ key, value }))
+  }
+  static addRecord(arr = [], key, value) {
+    if (!this.hasKeyValue(arr, key, value)) {
+      arr.push(this.init({ key, value }))
+    }
+    return arr
+  }
+  static appendRecord(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
+      }
+      return item
+    })
+  }
+  static appendValueArray(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
+      }
+      return item
+    })
+  }
+  static foundByKey(arr = [], key) {
+    const found = arr.find((m) => {
+      return this.sameKey(m, key)
+    })
+    return found || null
+  }
+  static foundValueByKey(arr = [], key) {
+    const found = this.foundByKey(arr, key)
+    return found ? found.value : null
+  }
+  static fromObject(options = {}) {
+    return Object.keys(options).reduce((acc, key) => {
+      acc.push(this.init({ key, value: options[key] }))
+      return acc
+    }, [])
+  }
+  static getValueByKey(arr = [], key) {
+    return this.foundValueByKey(arr, key)
+  }
+  static getValueByKeyFromArray(arr = [], key) {
+    if (arr.length === 0) {
+      return null
+    }
+    const firstArr = arr.shift()
+    const found = firstArr.find((i) => {
+      return this.sameKey(i, key)
+    })
+    if (found && found.value) {
+      return found.value
+    }
+    return this.getValueByKeyFromArray(arr, key)
+  }
+  static getValuesByKey(arr = [], key) {
+    return arr.reduce((acc, item) => {
+      if (this.sameKey(item, key)) {
+        acc.push(item.value)
+      }
+      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
+  }
+  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
+  }
+  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 removeByKey(arr, key) {
+    return arr.reduce((acc, item) => {
+      if (!this.sameKey(item, key)) {
+        acc.push(item)
+      }
+      return acc
+    }, [])
+  }
+  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
+    })
+  }
+  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
+  }
+}
+
+function _isSame(key1, key2) {
+  return key1 === key2
+}
+
+
+
+;// ./lib/models/keyValueObject/index.js
+
+
+
+
+;// ./lib/models/metadata/metadata.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
+  }
+  static get _classname() {
+    return 'Metadata'
+  }
+
+  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
+  }
+  static sameKey(item, key) {
+    return metadata_isSame(item.key, key)
+  }
+}
+
+function metadata_isSame(key1, key2) {
+  return stringFormatter(key1, DELIMITER) === stringFormatter(key2, DELIMITER)
+}
+
+
+
+;// ./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/trackedEntity/trackedEntity.js
+
+
+class TrackedEntity {
+  constructor(options = {}) {
+    options = options || {}
+    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 ?? '',
+    }
+
+    this.meta = { ..._tracking, ...options.meta }
+
+    // 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
+  }
+  get active() {
+    return this.meta?.active ?? this.active
+  }
+  get created() {
+    return this.meta?.created ?? this.created
+  }
+  get creator() {
+    return this.meta?.creator ?? this.creator
+  }
+  get deleted() {
+    return this.meta?.deleted ?? this.deleted
+  }
+  get modified() {
+    return this.meta?.modified ?? this.modified
+  }
+  get owner() {
+    return this.meta?.owner ?? this.owner
+  }
+  delete() {
+    return this.setDeleted()
+  }
+  setActive() {
+    if (this.meta) {
+      this.meta.active = true
+    } else {
+      this.active = true
+    }
+    return this
+  }
+  setDeleted() {
+    if (this.meta) {
+      this.meta.deleted = true
+    } else {
+      this.deleted = true
+    }
+    return this
+  }
+  setModified() {
+    const timestamp = Date.now()
+    if (this.meta) {
+      this.meta.modified = timestamp
+    } else {
+      this.modified = timestamp
+    }
+    return this
+  }
+  setOwner(owner) {
+    if (!owner) {
+      return this
+    }
+    if (this.meta) {
+      this.meta.owner = owner
+    } else {
+      this.owner = owner
+    }
+    return this
+  }
+  unsetActive() {
+    if (this.meta) {
+      this.meta.active = false
+    } else {
+      this.active = false
+    }
+    return this
+  }
+  unsetDeleted() {
+    if (this.meta) {
+      this.meta.deleted = false
+    } else {
+      this.deleted = false
+    }
+    return this
+  }
+
+  update(update) {
+    if (update.meta) {
+      this.meta = { ...this.meta, ...update.meta }
+    }
+    return this.setModified()
+  }
+}
+
+;// ./lib/models/trackedEntity/index.js
+
+ // Explicit named export (optional)
+
+;// ./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')
+    // }
+
+    super(options)
+
+    this._tenant = options._tenant
+
+    this.metadata = Metadata.initOnlyValidFromArray(options.metadata)
+    this.remarks = KeyValueObject.initOnlyValidFromArray(options.remarks)
+    this.tenantCode = options.tenantCode // Required for multi-tenancy
+  }
+
+  // Class methods
+  static get _classname() {
+    return 'TenantAwareEntity'
+  }
+  static get _superclass() {
+    return 'TenantAwareEntity'
+  }
+
+  // getters
+  get isValid() {
+    return super.isValid && !!this.tenantCode // Required for multi-tenancy
+  }
+
+  // instance methods
+  getMetadata() {
+    return this.metadata
+  }
+  getMetadataByKey(key) {
+    return Metadata.foundByKey(this.metadata, key)
+  }
+  getMetadataValueByKey(key) {
+    const found = this.getMetadataByKey(key)
+    return found ? found.value : null
+  }
+  getRemarks() {
+    return this.remarks
+  }
+  getRemarkByKey(key) {
+    return KeyValueObject.foundByKey(this.remarks, key)
+  }
+  getRemarksValueByKey(key) {
+    const found = this.getRemarkByKey(key)
+    return found ? found.value : null
+  }
+  getTenantCode() {
+    return this.tenantCode
+  }
+
+  update(update) {
+    if (update.metadata && Array.isArray(update.metadata)) {
+      this.metadata = Metadata.initOnlyValidFromArray(update.metadata)
+    }
+    if (update.remarks && Array.isArray(update.remarks)) {
+      this.remarks = KeyValueObject.initOnlyValidFromArray(update.remarks)
+    }
+    return super.update(update)
+  }
+}
+
+;// ./lib/models/tenantAwareEntity/index.js
+
+
+
+;// ./lib/models/uniqueKeyGenerator/uniqueKeyGenerator.js
+
+
+class UniqueKeyGenerator {
+  static get _classname() {
+    return 'UniqueKeyGenerator'
+  }
+  static get _superclass() {
+    return 'UniqueKeyGenerator'
+  }
+  static makeFormatter({ fieldName, format, options }) {
+    switch (format) {
+      case 'set_code':
+        return _makeSetCode(fieldName, options)
+      default:
+        return _makeSetCode(fieldName, 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
+    }
+  }
+}
+
+function _makeSetCode(fieldName, options) {
+  return async (obj = {}) => {
+    if (obj[fieldName]) {
+      return {}
+    }
+    return {
+      [fieldName]: stringHelper.setCode()
+    }
+  }
+}
+
+
+
+;// ./lib/models/uniqueKeyGenerator/index.js
+
+
+
+
+;// ./lib/models/index.js
+
+
+
+
+
+
+
+
+
+
+
+;// ./lib/index.js
+
+
+
+;// ./index.js
+
+
+export { ApiResponse, KeyValueObject, Metadata, QMeta, Repo, Service, TemplateCompiler, TenantAwareEntity, TrackedEntity, UniqueKeyGenerator, authorize, concatStringByArray, convertString, formatDate, generalPost, getValidation, getValueByKeys_getValueByKeys as getValueByKeys, init, initFromArray, initOnlyValidFromArray, makeApiResponse, makeService, objectHelper, pReduce, padZeros, stringFormatter, stringHelper, trackingPlugin };