@questwork/q-utilities 0.1.10 → 0.1.12

package/dist/index.min.cjs

@@ -57,11 +57,12 @@ __webpack_require__.d(__webpack_exports__, {
   Service: () => (/* reexport */ Service),
   TemplateCompiler: () => (/* reexport */ TemplateCompiler),
   UniqueKeyGenerator: () => (/* reexport */ UniqueKeyGenerator),
+  concatStringByArray: () => (/* reexport */ concatStringByArray),
   convertString: () => (/* reexport */ convertString),
   formatDate: () => (/* reexport */ formatDate),
   generalPost: () => (/* reexport */ generalPost),
   getValidation: () => (/* reexport */ getValidation),
-  getValueByKeys: () => (/* reexport */ getValueByKeys),
+  getValueByKeys: () => (/* reexport */ getValueByKeys_getValueByKeys),
   makeApiResponse: () => (/* reexport */ makeApiResponse),
   makeService: () => (/* reexport */ makeService),
   objectHelper: () => (/* reexport */ objectHelper),
@@ -71,86 +72,12 @@ __webpack_require__.d(__webpack_exports__, {
   stringHelper: () => (/* reexport */ stringHelper)
 });
 
-;// ./lib/helpers/convertString/convertString.js
-function convertString(string, patternMatch = /\$\{(.+?)\}/g, value, getValueByKeys) {
-  if (!string || typeof getValueByKeys !== 'function') {
-    return ''
-  }
-  const reg = new RegExp(patternMatch, 'g')
-  return string.replace(reg, (match, key) => {
-    const result = getValueByKeys({ keys: key.split('.'), obj: value })
-    if (result === null || result === undefined) {
-      return ''
-    }
-    return typeof result === 'object' ? JSON.stringify(result) : result
-  })
-}
-
-/* harmony default export */ const convertString_convertString = ({
-  convertString
-});
-
-
-;// ./lib/helpers/convertString/index.js
-
-
-;// ./lib/helpers/formatDate/formatDate.js
-
-function formatDate(date, format) {
-  const _date = date && date instanceof Date ? date : new Date(date)
-  const dayMapChi = ['日','一','二','三','四','五','六']
-  const dayMapEng = ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']
-  const dayMapEngShort = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
-  const _format = format || 'YYYY/MM/DD hh:mm'
-  const e = _date.getDay()
-  const ee = dayMapEngShort[e]
-  const eee = dayMapChi[e]
-  const eeee = dayMapEng[e]
-  const y = _date.getFullYear()
-  const m = _date.getMonth() + 1
-  const d = _date.getDate()
-  const h = _date.getHours()
-  const mm = _date.getMinutes()
-  const s = _date.getSeconds()
-
-  return _format.replace('YYYY', y)
-    .replace('MM', padding(m))
-    .replace('MM', padding(m))
-    .replace('DD', padding(d))
-    .replace('hh', padding(h))
-    .replace('mm', padding(mm))
-    .replace('ss', padding(s))
-    .replace('M', m)
-    .replace('D', d)
-    .replace('h', h)
-    .replace('m', mm)
-    .replace('s', s)
-    .replace('EEEE', padding(eeee))
-    .replace('EEE', padding(eee))
-    .replace('EE', padding(ee))
-    .replace('E', padding(e))
-}
-
-function padding(m) {
-  return m < 10 ? `0${m}` : m
-}
-
-
-/* harmony default export */ const formatDate_formatDate = ({
-  formatDate
-});
-
-
-
-;// ./lib/helpers/formatDate/index.js
-
-
 ;// ./lib/helpers/getValidation/getValidation.js
 function getValidation(rule, data, getDataByKey, KeyValueObject) {
   if (!rule) {
     return true
   }
-  if (typeof getDataByKey !== 'function' || typeof KeyValueObject !== 'function') {
+  if (typeof getDataByKey !== 'function' || (KeyValueObject && typeof KeyValueObject !== 'function')) {
     return false
   }
   const { key = '', value, keyValuePath = '' } = rule
@@ -242,6 +169,13 @@ function getValidation(rule, data, getDataByKey, KeyValueObject) {
       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 : []
@@ -273,12 +207,66 @@ function getValidation(rule, data, getDataByKey, KeyValueObject) {
 ;// ./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 string
-function getValueByKeys(keys, data) {
+// keys can be array or object or string
+function getValueByKeys_getValueByKeys(keys, data) {
   let _keys = keys
   let _data = data
-  if (!Array.isArray(keys)) {
+  if (typeof keys === 'string') {
+    _keys = _keys.split('.')
+  }
+  if (!Array.isArray(keys) && typeof keys === 'object') {
     const { keys: keyArr, obj } = keys
     _keys = keyArr
     _data = obj
@@ -288,7 +276,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]
@@ -296,8 +284,8 @@ function getValueByKeys(keys, data) {
   return _data
 
 }
-/* harmony default export */ const getValueByKeys_getValueByKeys = ({
-  getValueByKeys
+/* harmony default export */ const getValueByKeys = ({
+  getValueByKeys: getValueByKeys_getValueByKeys
 });
 
 
@@ -305,950 +293,909 @@ function getValueByKeys(keys, data) {
 ;// ./lib/helpers/getValueByKeys/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]
-      if (part.endsWith('[]')) {
-        // 处理数组遍历
-        const key = part.slice(0, -2) // 去掉 '[]' 得到属性名
-        if (Array.isArray(current[key])) {
-          current[key].forEach((item) => set(item, parts.slice(i + 1).join('.'), value))
-        }
-        return // 处理完数组后直接返回
-      }
-      if (part.includes('[') && part.includes(']')) {
-        // 处理数组索引
-        const arrayMatch = part.match(/(\w+)\[(\d+)\]/)
-        if (arrayMatch) {
-          const key = arrayMatch[1]
-          const index = arrayMatch[2]
-          if (Array.isArray(current[key]) && current[key][index]) {
-            current = current[key][index]
-          } else {
-            return // 如果数组或索引不存在，直接返回
-          }
-        }
-      } else {
-        // 处理普通属性
-        if (!current[part]) {
-          current[part] = {} // 如果属性不存在，创建一个空对象
-        }
-        current = current[part]
-      }
-    }
-  
-    // 设置最终属性值
-    const lastPart = parts[parts.length - 1]
-    current[lastPart] = value
-  }
+;// ./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'
 }
 
-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]
-      }
-    }
+class TemplateCompilerException extends Error {
+  constructor(message) {
+    super(message)
+    this.message = message
   }
-
-  // 继续合并剩余的源对象
-  return merge(target, ...sources)
 }
 
-function _isObject(obj) {
-  return obj && typeof obj === 'object' && !Array.isArray(obj)
-}
 
 
+;// ./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'
+]
+const _HIDE = '_HIDE'
+const _NOT_EMPTY = '_NOT_EMPTY'
+const _SELF = '_SELF'
+const TAGS_EJS = ['<%=', '%>']
+const TAGS_HANDLEBAR = ['{{', '}}']
 
-;// ./lib/helpers/objectHelper/index.js
 
 
+;// ./lib/models/templateCompiler/helpers/_concatIf.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
-			}
+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
+}
 
-			try {
-				const [resolvedTotal, resolvedValue] = await Promise.all([total, element.value])
-				next(reducer(resolvedTotal, resolvedValue, index++))
-			} catch (error) {
-				reject(error)
-			}
-		}
 
-		next(initialValue)
-	})
-}
 
+;// ./lib/models/templateCompiler/helpers/_eq.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
+
+function _eq(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`eq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
   }
-  static get _classname() {
-    return 'ApiResponse'
+  if (data === null || (typeof data === 'undefined')) {
+    return null
   }
-  static get _superclass() {
-    return 'ApiResponse'
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
   }
+  const expected = args[0]
+  return data === expected ? args[1] : args[2]
+}
 
-  // getters
-  get data() {
-    if (this._instanceBuilder && (typeof this._instanceBuilder === 'function')) {
-      return this._data.map(this._instanceBuilder)
-    }
-    return this._data
+
+
+;// ./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/apiResponse/makeApiResponse.js
+;// ./lib/models/templateCompiler/helpers/_filterAll.js
 
 
-function makeApiResponse({ repo, result }) {
-  return ApiResponse.init({
-    ...result,
-    _instanceBuilder: (i) => {
-      return repo.init(i)
+
+// 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)
+    })
+  }
 
-;// ./lib/models/apiResponse/index.js
-
+  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
 
-;// ./lib/models/keyValueObject/keyValueObject.js
-class KeyValueObject {
-  constructor(options = {}) {
-    options = options || {}
-    this.key = options.key || null
-    this.value = (typeof options.value !== 'undefined') ? options.value : ''
+  // the arg is boolean
+  if (typeof arg === 'boolean') {
+    return arg === value
   }
 
-  // Class methods
-  static init(options = {}) {
-    if (options instanceof this) {
-      return options
+  // 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
     }
-    const instance = new this(options)
-    return instance.isValid ? instance : null
-  }
-  static initFromArray(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.map((a) => this.init(a))
+    if (typeof value === 'string') {
+      return arg === '' ? value === '' : value !== ''
     }
-    return []
-  }
-  static initOnlyValidFromArray(arr = []) {
-    return this.initFromArray(arr).filter((i) => i)
-  }
-  static get _classname() {
-    return 'KeyValueObject'
-  }
-  static get _superclass() {
-    return 'KeyValueObject'
+    if (Array.isArray(value)) {
+      return arg === '' ? value.length === 0 : value.length !== 0
+    }
+    return arg !== ''
   }
 
-  static addItem(arr, key, value) {
-    arr.push(this.init({ key, value }))
+  // the arg is alphabetic or number
+  if (_isPureStringOrNumber(arg)) {
+    return arg === value
   }
-  static addRecord(arr = [], key, value) {
-    if (!this.hasKeyValue(arr, key, value)) {
-      arr.push(this.init({ key, value }))
+
+  // the arg is array of [] or [*]: [] => Empty, [*] => Not Empty
+  if (arg.startsWith('[') && arg.endsWith(']')) {
+    if (arg === '[]') {
+      return Array.isArray(value) && value.length === 0
     }
-    return arr
-  }
-  static appendRecord(arr = [], key, value) {
-    return arr.map((item) => {
-      if (this.sameKey(item, key)) {
-        item.value = [...item.value, ...value]
-      }
-      return item
-    })
+    if (arg === '[*]') {
+      return Array.isArray(value) && value.length !== 0
+    }
+    return false
   }
-  static appendValueArray(arr = [], key, value) {
-    return arr.map((item) => {
-      if (this.sameKey(item, key)) {
-        item.value = [...item.value, ...value]
-      }
-      return item
-    })
+
+  // the arg is 'operator + string | number'
+  const { operator, value: argValue } = _splitOperator(arg)
+  if (!operator || (argValue !== 0 && !argValue)) {
+    return false
   }
-  static foundByKey(arr = [], key) {
-    const found = arr.find((m) => {
-      return this.sameKey(m, key)
-    })
-    return found || null
+  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
   }
-  static foundValueByKey(arr = [], key) {
-    const found = this.foundByKey(arr, key)
-    return found ? found.value : null
+}
+
+function _isPureStringOrNumber(input) {
+  if (typeof input === 'string') {
+    if (input.startsWith('[') && input.endsWith(']')) {
+      return false
+    }
+    if (/!=|>=|<=|>|</.test(input)) {
+      return false
+    }
+    return true
   }
-  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)
+  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 }
   }
-  static getValuesByKey(arr = [], key) {
-    return arr.reduce((acc, item) => {
-      if (this.sameKey(item, key)) {
-        acc.push(item.value)
-      }
-      return acc
-    }, [])
+
+  // 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
   }
-  static hasKeyValue(arr = [], key, value) {
-    if (typeof value === 'undefined') {
-      return arr.filter((item) => this.sameKey(item, key)).length > 0
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_filterOne.js
+
+
+
+function _filterOne(data, args) {
+  try {
+    const list = _filterAll(data, args)
+    if (list.length === 1) {
+      return list[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)
+    if (list.length === 0) {
+      return null
     }
-    return copy
+    throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.resultMoreThanOneException)
+  } catch (e) {
+    throw e
   }
-  static keys(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc.push(item.key)
-        return acc
-      }, [])
-    }
-    return []
+}
+
+
+
+;// ./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`)
   }
-  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
+
+  if (timestamp === null || timestamp === undefined) {
+    return null
   }
-  static removeByKey(arr, key) {
-    return arr.reduce((acc, item) => {
-      if (!this.sameKey(item, key)) {
-        acc.push(item)
-      }
-      return acc
-    }, [])
+
+  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')
   }
-  static sameKey(item, key) {
-    return _isSame(item.key, key)
+
+  // 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(', ')}`
+    )
   }
-  static toObject(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc[item.key] = item.value
-        return acc
-      }, {})
+
+  // 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)
     }
-    return {}
-  }
-  static toString(arr = [], delimiter = '; ') {
-    if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc.push(`${item.key}: ${item.value}`)
-        return acc
-      }, []).join(delimiter)
+    if (data === null) {
+      return null
     }
-    return ''
-  }
-  static updateRecord(arr = [], key, value) {
-    return arr.map((item) => {
-      if (this.sameKey(item, key)) {
-        return {
-          ...item,
-          value
+    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)
       }
-      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
+    if (typeof data[key] !== 'undefined') {
+      return data[key]
     }
-    return obj
+    return _handleFailover(key, failover)
+  } catch (e) {
+    throw e
   }
 }
 
-function _isSame(key1, key2) {
-  return key1 === key2
+function _handleFailover(key, failover) {
+  if (failover !== null) {
+    return failover
+  }
+  return null
+  // throw new TemplateCompilerException(`Key "${key}" does not exist and no failover`)
 }
 
 
 
-;// ./lib/models/keyValueObject/index.js
+;// ./lib/models/templateCompiler/helpers/_gt.js
 
 
 
 
-;// ./lib/helpers/stringFormatter/stringFormatter.js
-function stringFormatter(str, delimiter = '_') {
-  if (str === null || typeof str === 'undefined' || typeof str.toString === 'undefined') {
+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
   }
-  return str.toString()
-    .trim()
-    .toUpperCase()
-    .replace('-', delimiter)
-    .replace(' ', delimiter)
+  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/metadata/metadata.js
+;// ./lib/models/templateCompiler/helpers/_gte.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
+function _gte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_gte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
   }
-  static get _classname() {
-    return 'Metadata'
+  if (data === null || (typeof data === 'undefined')) {
+    return null
   }
-
-  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)
-      }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
     })
-    return toArr
-  }
-  static sameKey(item, key) {
-    return metadata_isSame(item.key, key)
   }
+  const expected = args[0]
+  return data >= expected ? args[1] : args[2]
 }
 
-function metadata_isSame(key1, key2) {
-  return stringFormatter(key1, DELIMITER) === stringFormatter(key2, DELIMITER)
-}
 
 
+;// ./lib/models/templateCompiler/helpers/_isEmpty.js
 
-;// ./lib/models/metadata/index.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/qMeta/qMeta.js
 
 
-const updateAllowedProps = [
-  'attributes',
-  'ref'
-]
+;// ./lib/models/templateCompiler/helpers/_isNotEmpty.js
 
-class QMeta {
-  constructor(options = {}) {
-    options = options || {}
-    this.attributes = KeyValueObject.initOnlyValidFromArray(options.attributes)
-    this.ref = options.ref || {}
-  }
 
-  static get _classname() {
-    return 'QMeta'
+
+
+function _isNotEmpty(data, args) {
+  if (args.length !== 2) {
+    throw new TemplateCompilerException(`_isNotEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
   }
-  static get _superclass() {
-    return 'QMeta'
+  // if (data === null || (typeof data === 'undefined')) {
+  //   return null
+  // }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
   }
-
-  // Class methods
-  static init(options = {}) {
-    if (options instanceof QMeta) {
-      return options
-    }
-    return new QMeta(options)
+  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
+    return args[1]
   }
-
-  // instance methods
-  addAttribute(obj) {
-    const kvObject = KeyValueObject.init(obj)
-    if (!kvObject) {
-      throw new Error('invalid meta attribute')
-    }
-    this.attributes.push(kvObject)
-    return this
+  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]
+}
 
-  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/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/qMeta/index.js
 
+;// ./lib/models/templateCompiler/helpers/_lt.js
 
 
 
-;// ./lib/models/repo/repo.js
-class Repo {
-  constructor(options) {
-    options = options || {}
-    this.model = options.model
-    this._sharedOptions = options._sharedOptions // { session: this.dbTransaction }
-    this._queryOptions = options._queryOptions
-    this._saveOptions = options._saveOptions
-    this._Class = options._constructor && options._constructor._Class
-      ? options._constructor._Class
-      : null
-  }
-  static init(options = {}) {
-    if (options instanceof this) {
-      return options
-    }
-    const instance = new this(options)
-    return instance.isValid ? instance : null
+
+function _lt(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
   }
-  static get _classname() {
-    return 'Repo'
+  if (data === null || (typeof data === 'undefined')) {
+    return null
   }
-  static get _superclass() {
-    return 'Repo'
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
   }
+  const expected = args[0]
+  return data < expected ? args[1] : args[2]
+}
 
-  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')
-  }
+;// ./lib/models/templateCompiler/helpers/_lte.js
 
-  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
-    }
+function _lte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
   }
-
-  // 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)
-        }
-      })
+  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]
+}
 
-  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]
+
+;// ./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
-      }))
-    return promise.then((savedData) => {
-      if (savedData.length !== 1) isNew = null
-      const result = {
-        data: savedData,
-        isNew,
-        total: savedData.length
+      })
+      if (acc.hasFormat) {
+        acc.content.push(list)
+      } else {
+        acc.content = acc.content.concat(list)
       }
-      log({ level: 'info', output: { ...result } })
-      return result
-    }).catch((err) => {
-      log({ level: 'warn', output: err.toString() })
-      throw err
+      return acc
+    }, {
+      content: [],
+      hasFormat: false
     })
+    return result.content
+  } catch (e) {
+    throw e
   }
+}
 
-  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)
-        }
-      })
+
+
+;// ./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]
 }
 
-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/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/repo/index.js
+;// ./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/service/service.js
 
+;// ./lib/models/templateCompiler/helpers/index.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)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./lib/models/templateCompiler/templateCompiler.js
+
+
+
+
+class TemplateCompiler {
+  constructor(data) {
+    this.data = data
   }
-  initFromArray(arr = []) {
+  static init(options) {
+    return new this(options)
+  }
+  static initFromArray(arr = []) {
     if (Array.isArray(arr)) {
       return arr.map((a) => this.init(a))
     }
     return []
   }
-  initOnlyValidFromArray(arr = []) {
+  static initOnlyValidFromArray(arr = []) {
     return this.initFromArray(arr).filter((i) => i)
   }
+  static concatIf(data, args) {
+    return _concatIf(data, args)
+  }
+  static eq(data, args) {
+    return _eq(data, args)
+  }
 
-  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 filterAll(data, args) {
+    return _filterAll(data, args)
   }
 
-  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 formatDate(data, args) {
+    return _formatDate(data, args)
   }
-}
-
-function makeService({ repo }) {
-  if (repo === undefined) {
-    throw new Error('repo is required.')
+  
+  static get(data, key, failover = null) {
+    return _get(data, key, failover)
   }
-  if (repo._superclass !== Repo._superclass) {
-    throw new Error('repo is not an instance of Repo.')
+  static gt(data, args) {
+    return _gt(data, args)
   }
-  return new Service({ repo })
-}
-
-
-
-;// ./lib/models/service/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
+  static gte(data, args) {
+    return _gte(data, args)
   }
-}
-
-
-
-;// ./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'
-]
-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(', ')}`)
+  static isEmpty(data, args) {
+    return _isEmpty(data, args)
   }
-  if (args.length !== 3) {
-    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  static isNotEmpty(data, args) {
+    return _isNotEmpty(data, args)
   }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
+  static join(data, separator = '') {
+    return _join(data, separator)
   }
-  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}`)
+  static lt(data, args) {
+    return _lt(data, args)
   }
-  if (data === '' && failover.includes(_HIDE)) {
-    return ''
+  static lte(data, args) {
+    return _lte(data, args)
   }
-  if (data !== '' && (data !== null || data !== undefined) && failover.includes(_HIDE)) {
-    return `${success[0]}${data}${success[success.length - 1]}`
+  static map(data, args = []) {
+    return _map(data, args)
+  }
+  static neq(data, args) {
+    return _neq(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)
+  }
+
+  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}`)
   }
-  return failover
 }
 
+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)]
+}
 
-;// ./lib/models/templateCompiler/helpers/_eq.js
+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)
+    }
 
+    const _input = _toBasicType(input)
 
+    if (typeof _input !== 'string') {
+      return _input
+    }
 
-function _eq(data, args) {
-  if (args.length !== 3) {
-    throw new TemplateCompilerException(`eq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+    // 如果是一个列表形式（例如 ["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
   }
-  if (data === null || (typeof data === 'undefined')) {
+  return input
+}
+
+function _toBasicType(input) {
+  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 (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
+  if (!Number.isNaN(input) && !Number.isNaN(Number.parseFloat(input))) {
+    return Number(input)
   }
-  const expected = args[0]
-  return data === expected ? args[1] : args[2]
+  return input
 }
 
-
-
-;// ./lib/models/templateCompiler/helpers/_exec.js
-function _exec(data, args) {
+function _callFunction(data, functionName, parameters) {
   try {
-    const [methodName, ..._args] = args
-    return data[methodName](..._args)
+    let failover
+    switch (functionName) {
+      case 'exec':
+        return _exec(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 '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 'toLowerCase':
+        return _toLowerCase(data)
+      case 'toUpperCase':
+        return _toUpperCase(data)
+      default:
+        throw new Error(`${functionName} is not a valid function`)
+    }
   } catch (e) {
     throw e
   }
@@ -1256,817 +1203,955 @@ function _exec(data, args) {
 
 
 
-;// ./lib/models/templateCompiler/helpers/_filterAll.js
+;// ./lib/models/templateCompiler/index.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
-  }
-}
+;// ./lib/helpers/concatStringByArray/concatStringByArray.js
 
-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(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(key.split('.'), e) : e[key]
-    return _args.some((arg) => _performOperation(arg, value))
-  })
+
+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
+});
 
-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
-  }
+;// ./lib/helpers/concatStringByArray/index.js
 
-  // 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
-  }
+;// ./lib/helpers/convertString/convertString.js
 
-  // 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 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
+  })
 }
 
-function _isPureStringOrNumber(input) {
-  if (typeof input === 'string') {
-    if (input.startsWith('[') && input.endsWith(']')) {
-      return false
-    }
-    if (/!=|>=|<=|>|</.test(input)) {
-      return false
+/* 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]
+      if (part.endsWith('[]')) {
+        // 处理数组遍历
+        const key = part.slice(0, -2) // 去掉 '[]' 得到属性名
+        if (Array.isArray(current[key])) {
+          current[key].forEach((item) => set(item, parts.slice(i + 1).join('.'), value))
+        }
+        return // 处理完数组后直接返回
+      }
+      if (part.includes('[') && part.includes(']')) {
+        // 处理数组索引
+        const arrayMatch = part.match(/(\w+)\[(\d+)\]/)
+        if (arrayMatch) {
+          const key = arrayMatch[1]
+          const index = arrayMatch[2]
+          if (Array.isArray(current[key]) && current[key][index]) {
+            current = current[key][index]
+          } else {
+            return // 如果数组或索引不存在，直接返回
+          }
+        }
+      } else {
+        // 处理普通属性
+        if (!current[part]) {
+          current[part] = {} // 如果属性不存在，创建一个空对象
+        }
+        current = current[part]
+      }
     }
-    return true
+  
+    // 设置最终属性值
+    const lastPart = parts[parts.length - 1]
+    current[lastPart] = value
   }
-  return !Number.isNaN(input)
 }
 
-function _splitOperator(str) {
-  const operators = ['!=', '>=', '<=', '>', '<']
-
-  const matchedOp = operators.find((op) => str.startsWith(op))
-  if (!matchedOp) return { operator: null, value: null }
+function merge(target, ...sources) {
+  if (!sources.length) return target
 
-  const remaining = str.slice(matchedOp.length)
+  const source = sources.shift() // 取出第一个源对象
 
-  // '>Primary' or '<Primary' is invalid
-  if (/^[a-zA-Z]*$/.test(remaining) && matchedOp !== '!=') {
-    return { operator: null, value: null }
+  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]
+      }
+    }
   }
 
-  // if it is a number it is converted to a number
-  const value = (!Number.isNaN(parseFloat(remaining)) && !Number.isNaN(remaining)) ? Number(remaining) : remaining
+  // 继续合并剩余的源对象
+  return merge(target, ...sources)
+}
 
-  return {
-    operator: matchedOp,
-    value
-  }
+function _isObject(obj) {
+  return obj && typeof obj === 'object' && !Array.isArray(obj)
 }
 
 
 
-;// ./lib/models/templateCompiler/helpers/_filterOne.js
+;// ./lib/helpers/objectHelper/index.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/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()
 
-;// ./lib/models/templateCompiler/helpers/_formatDate.js
+			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)
+			}
+		}
 
-function _formatDate(timestamp, format) {
-  if (format.length === 0) {
-    throw new TemplateCompilerException(`_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: format parts must be not empty array`)
-  }
+		next(initialValue)
+	})
+}
 
-  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')
+;// ./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
   }
 
-  // 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(', ')}`
-    )
+  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'
   }
 
-  // Build the formatted string using reduce
-  return format.reduce((result, part) => result + (partsMap[part] || part), '')
+  // getters
+  get data() {
+    if (this._instanceBuilder && (typeof this._instanceBuilder === 'function')) {
+      return this._data.map(this._instanceBuilder)
+    }
+    return this._data
+  }
 }
 
 
 
-;// ./lib/models/templateCompiler/helpers/_get.js
+;// ./lib/models/apiResponse/makeApiResponse.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]
+function makeApiResponse({ repo, result }) {
+  return ApiResponse.init({
+    ...result,
+    _instanceBuilder: (i) => {
+      return repo.init(i)
     }
-    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/apiResponse/index.js
 
-;// ./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(', ')}`)
+;// ./lib/models/keyValueObject/keyValueObject.js
+class KeyValueObject {
+  constructor(options = {}) {
+    options = options || {}
+    this.key = options.key || null
+    this.value = (typeof options.value !== 'undefined') ? options.value : ''
   }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
+
+  // Class methods
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
+    }
+    const instance = new this(options)
+    return instance.isValid ? instance : null
   }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
+  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'
   }
-  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(', ')}`)
+  static addItem(arr, key, value) {
+    arr.push(this.init({ key, value }))
   }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
+  static addRecord(arr = [], key, value) {
+    if (!this.hasKeyValue(arr, key, value)) {
+      arr.push(this.init({ key, value }))
+    }
+    return arr
   }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
+  static appendRecord(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
+      }
+      return item
     })
   }
-  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(', ')}`)
+  static appendValueArray(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
+      }
+      return item
+    })
   }
-  // if (data === null || (typeof data === 'undefined')) {
-  //   return null
-  // }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
+  static foundByKey(arr = [], key) {
+    const found = arr.find((m) => {
+      return this.sameKey(m, key)
     })
+    return found || null
   }
-  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
-    return args[0]
+  static foundValueByKey(arr = [], key) {
+    const found = this.foundByKey(arr, key)
+    return found ? found.value : null
   }
-  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(', ')}`)
+  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 {}
   }
-  // if (data === null || (typeof data === 'undefined')) {
-  //   return null
-  // }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
+  static toString(arr = [], delimiter = '; ') {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc.push(`${item.key}: ${item.value}`)
+        return acc
+      }, []).join(delimiter)
+    }
+    return ''
   }
-  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
-    return args[1]
+  static updateRecord(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        return {
+          ...item,
+          value
+        }
+      }
+      return item
+    })
   }
-  if (Array.isArray(data) && data.length === 0) {
-    return args[1]
+  static updateOrInsertRecord(arr = [], key, value) {
+    return this.insertOrUpdateRecord(arr, key, value)
   }
-  if (typeof data === 'string' && data === '') {
-    return args[1]
+  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 []
   }
-  if (data === null || data === undefined) {
-    return args[1]
+  static values(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc.push(item.value)
+        return acc
+      }, [])
+    }
+    return []
   }
-  return args[0]
-}
 
+  // getters
+  get isValid() {
+    return !!this.key
+  }
 
-;// ./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
+  get toObject() {
+    const obj = {}
+    if (this.isValid) {
+      obj[this.key] = this.value
+    }
+    return obj
   }
 }
 
-function _stringifyObject(obj) {
-  return JSON.stringify(obj).replace(/"([^"]+)":/g, '$1: ').replace(/"([^"]+)"/g, '$1').replace(/,/g, ', ')
+function _isSame(key1, key2) {
+  return key1 === key2
 }
 
 
 
-;// ./lib/models/templateCompiler/helpers/_lt.js
+;// ./lib/models/keyValueObject/index.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')) {
+;// ./lib/helpers/stringFormatter/stringFormatter.js
+function stringFormatter(str, delimiter = '_') {
+  if (str === null || typeof str === 'undefined' || typeof str.toString === '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]
+  return str.toString()
+    .trim()
+    .toUpperCase()
+    .replace('-', delimiter)
+    .replace(' ', delimiter)
 }
 
 
 
-;// ./lib/models/templateCompiler/helpers/_lte.js
+;// ./lib/models/metadata/metadata.js
 
 
 
+const DELIMITER = '_'
 
-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
+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'
   }
-  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
+  static merge(toArr, fromArr) {
+    (fromArr || []).map((from) => {
+      const found = toArr.find((to) => {
+        return metadata_isSame(to.key, from.key)
       })
-      if (acc.hasFormat) {
-        acc.content.push(list)
+      if (found) {
+        found.value = (found.value || []).concat(from.value)
       } else {
-        acc.content = acc.content.concat(list)
+        toArr.push(from)
       }
-      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
     })
+    return toArr
   }
-  const expected = args[0]
-  return data !== expected ? args[1] : args[2]
-}
-
-
-
-;// ./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
+  static sameKey(item, key) {
+    return metadata_isSame(item.key, key)
   }
-  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()
+function metadata_isSame(key1, key2) {
+  return stringFormatter(key1, DELIMITER) === stringFormatter(key2, DELIMITER)
 }
 
 
 
-;// ./lib/models/templateCompiler/helpers/index.js
-
-
-
-
-
-
-
+;// ./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/templateCompiler/templateCompiler.js
+;// ./lib/models/qMeta/index.js
 
 
 
 
-class TemplateCompiler {
-  constructor(data) {
-    this.data = data
-  }
-  static init(options) {
-    return new this(options)
+;// ./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 initFromArray(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.map((a) => this.init(a))
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
     }
-    return []
-  }
-  static initOnlyValidFromArray(arr = []) {
-    return this.initFromArray(arr).filter((i) => i)
+    const instance = new this(options)
+    return instance.isValid ? instance : null
   }
-  static concatIf(data, args) {
-    return _concatIf(data, args)
+  static get _classname() {
+    return 'Repo'
   }
-  static eq(data, args) {
-    return _eq(data, args)
+  static get _superclass() {
+    return 'Repo'
   }
 
-  static filterAll(data, args) {
-    return _filterAll(data, args)
+  get _classname() {
+    return 'Repo'
   }
 
-  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)
+  get _superclass() {
+    return 'Repo'
   }
-  static isNotEmpty(data, args) {
-    return _isNotEmpty(data, args)
+
+  get isValid() {
+    return this.model
+      && (typeof this.model.deleteOne === 'function')
+      && (typeof this.model.findAll === 'function')
+      && (typeof this.model.saveOne === 'function')
   }
-  static join(data, separator = '') {
-    return _join(data, separator)
+
+  get queryOptions() {
+    return {
+      ...this._sharedOptions,
+      ...this._queryOptions,
+    }
   }
-  static lt(data, args) {
-    return _lt(data, args)
+
+  get saveOptions() {
+    return {
+      ...this._sharedOptions,
+      ...this._saveOptions,
+    }
   }
-  static lte(data, args) {
-    return _lte(data, args)
+
+  init(options) {
+    if (this._Class && typeof this._Class.init === 'function') {
+      return this._Class.init(options)
+    }
+    return options
   }
-  static map(data, args = []) {
-    return _map(data, args)
+
+  async deleteOne({ id }) {
+    try {
+      const result = await this.model.deleteOne({ _id: id })
+      return {
+        ...result, // { message: 'ok', total }
+        isNew: false,
+        data: []
+      }
+    } catch (err) {
+      throw err
+    }
   }
-  static neq(data, args) {
-    return _neq(data, args)
+
+  // 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 toLowerCase(data, args) {
-    return _toLowerCase(data, args)
+
+  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
+      })
   }
-  static toUpperCase(data, args) {
-    return _toUpperCase(data, args)
+
+  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 parseFunction(expression) {
-    return _parseFunction(expression, _FN_NAMES)
+
+  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)
+        }
+      })
+    })
   }
+}
 
-  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}`)
-      }
+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
+          }
+        }
+      })
     }
-    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
-  })
-}
+;// ./lib/models/repo/index.js
 
-function _parseSinglePart(input) {
-  if (typeof input === 'string') {
-    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
+;// ./lib/models/service/service.js
+
+
+
+class Service {
+  constructor({ repo }) {
+    this.repo = repo
   }
-  return input
-}
 
-function _toBasicType(input) {
-  if (input.startsWith('"') && input.endsWith('"')) {
-    // 去掉双引号，返回
-    return input.substring(1, input.length - 1)
+  static get _classname() {
+    return 'Service'
   }
-  if (input === 'true') {
-    return true
+  static get _superclass() {
+    return 'Service'
   }
-  if (input === 'false') {
-    return false
+
+  deleteOne({ id }) {
+    return this.repo.deleteOne({ id })
+      .catch(() => {
+        throw new Error(`Not found for query: ${id}`)
+      })
   }
-  if (input === 'undefined') {
-    return undefined
+
+  async findAll({ query = {}, systemLog } = {}) {
+    const result = await this.repo.findAll({ query, systemLog })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
   }
-  if (input === 'null') {
-    return null
+
+  async findOne({ query = {}, systemLog } = {}) {
+    const result = await this.repo.findOne({ query, systemLog })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
   }
-  if (!Number.isNaN(input) && !Number.isNaN(Number.parseFloat(input))) {
-    return Number(input)
+
+  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)
   }
-  return input
-}
 
-function _callFunction(data, functionName, parameters) {
-  try {
-    let failover
-    switch (functionName) {
-      case 'exec':
-        return _exec(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 '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 'toLowerCase':
-        return _toLowerCase(data)
-      case 'toUpperCase':
-        return _toUpperCase(data)
-      default:
-        throw new Error(`${functionName} is not a valid function`)
+  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
+    })
+  }
+
+  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
+      })
     }
-  } catch (e) {
-    throw e
+    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/templateCompiler/index.js
+;// ./lib/models/service/index.js
 
 
 
@@ -2315,6 +2400,7 @@ const stringHelper = {
 
 
 
+
 ;// ./lib/index.js