@questwork/q-utilities 0.1.8 → 0.1.10

package/dist/index.min.cjs

@@ -55,7 +55,7 @@ __webpack_require__.d(__webpack_exports__, {
   QMeta: () => (/* reexport */ QMeta),
   Repo: () => (/* reexport */ Repo),
   Service: () => (/* reexport */ Service),
-  Template: () => (/* reexport */ Template),
+  TemplateCompiler: () => (/* reexport */ TemplateCompiler),
   UniqueKeyGenerator: () => (/* reexport */ UniqueKeyGenerator),
   convertString: () => (/* reexport */ convertString),
   formatDate: () => (/* reexport */ formatDate),
@@ -232,6 +232,16 @@ function getValidation(rule, data, getDataByKey, KeyValueObject) {
       }
       return false
     }
+    case '$intervalTimeGt': {
+      const now = new Date().getTime()
+      const timestamp = new Date(rowValue).getTime()
+      return (now - timestamp) > value['$intervalTimeGt']
+    }
+    case '$intervalTimeLt': {
+      const now = new Date().getTime()
+      const timestamp = new Date(rowValue).getTime()
+      return (now - timestamp) < value['$intervalTimeLt']
+    }
     case '$notInValue': {
       const result = getDataByKey(value['$notInValue'], data)
       const _value = Array.isArray(result) ? result : []
@@ -961,11 +971,11 @@ class Repo {
           reject(new Error('more than one is found'))
         }
       })
-        .catch((err) => {
-          log({ level: 'warn', output: err.toString() })
-          throw err
-        })
     })
+      .catch((err) => {
+        log({ level: 'warn', output: err.toString() })
+        throw err
+      })
   }
 
   saveAll({ docs, systemLog }) {
@@ -979,14 +989,14 @@ class Repo {
     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
-        }))
+        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 = {
@@ -1146,10 +1156,31 @@ function makeService({ repo }) {
 
 
 
-;// ./lib/models/template/constants.js
+;// ./lib/models/templateCompiler/templateCompilerException.js
+const TEMPLATE_COMPILER_EXCEPTION_TYPE = {
+  argumentEmptyException: 'Argument is empty',
+  argumentFormatException: 'Incorrect number or format of argument',
+  invalidFuntionException: 'Function Name is invalid',
+  invalidRegExpException: 'Invalid regular expression',
+  isNotAFunctionException: 'Is not a function',
+  notExistException: 'Key does not exist',
+  resultEmptyException: 'Result is empty',
+  resultMoreThanOneException: 'More than one result'
+}
+
+class TemplateCompilerException extends Error {
+  constructor(message) {
+    super(message)
+    this.message = message
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/constants.js
 const _EMPTY = '_EMPTY'
 const _FN_NAMES = [
-  'get', 'map', 'join', 'concatIf', 'filterOne', 'filterAll', 'formatDate', 'eq', 'neq', 'gt', 'lt', 'gte', 'lte', 'isEmpty', 'isNotEmpty', 'toLowerCase', 'toUpperCase'
+  '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'
@@ -1159,11 +1190,47 @@ const TAGS_HANDLEBAR = ['{{', '}}']
 
 
 
-;// ./lib/models/template/helpers/_eq.js
+;// ./lib/models/templateCompiler/helpers/_concatIf.js
+
+
+
+
+function _concatIf(data, args) {
+  if (typeof data !== 'string') {
+    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string :${data.join(', ')}`)
+  }
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  const [condition, success, failover] = args
+  const validConditions = [_EMPTY, _NOT_EMPTY]
+  if (validConditions.includes(condition) || success.length !== 2) {
+    throw new TemplateCompilerException(`concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException}: ${condition}, ${success}`)
+  }
+  if (data === '' && failover.includes(_HIDE)) {
+    return ''
+  }
+  if (data !== '' && (data !== null || data !== undefined) && failover.includes(_HIDE)) {
+    return `${success[0]}${data}${success[success.length - 1]}`
+  }
+  return failover
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_eq.js
+
+
 
 
 function _eq(data, args) {
-  if (data === null || (typeof data === 'undefined') || args.length !== 3) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`eq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
     return null
   }
   if (args.includes(_SELF)) {
@@ -1177,107 +1244,264 @@ function _eq(data, args) {
 
 
 
-;// ./lib/models/template/templateException.js
-const TEMPLATE_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 TemplateException extends Error {
-  constructor(message) {
-    super(message)
-    this.message = message
+;// ./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/template/helpers/_filterAll.js
+;// ./lib/models/templateCompiler/helpers/_filterAll.js
+
 
 
-const _filterAll_DELIMITER = '~~~'
+// const DELIMITER = '~~~'
 
 function _filterAll(data, args) {
-  if (!Array.isArray(data) || data.length === 0 || !Array.isArray(args) || args.length === 0) {
+  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
   }
+}
 
-  if (typeof data[0] === 'object') {
-    return _existObject(data, args)
-  }
+function _exist(data, args) {
+  const _args = args.flat()
+  return data.filter((e) => _args.some((arg) => _performOperation(arg, e)))
+}
 
-  if (typeof data[0] === 'string' || typeof data[0] === 'number') {
-    return _exist(data, args)
+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)
+    })
   }
 
-  return []
-}
+  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
+  }
 
-function _exist(data, args) {
-  const _str = `${_filterAll_DELIMITER}${args.join(_filterAll_DELIMITER)}${_filterAll_DELIMITER}`
+  const [key, ..._argsArr] = args
+  const _args = _argsArr.flat()
   return data.filter((e) => {
-    return _str.includes(`${_filterAll_DELIMITER}${e}${_filterAll_DELIMITER}`) && args.includes(e)
+    const value = key.includes('.') ? getValueByKeys(key.split('.'), e) : e[key]
+    return _args.some((arg) => _performOperation(arg, value))
   })
 }
 
-function _existObject(data, args) {
-  if (args.length !== 2) {
-    return []
+function _performOperation(arg, value) {
+  // the arg is undefined
+  if (arg === undefined && value === undefined) return true
+
+  // the arg is null
+  if (arg === null && value === null) return true
+
+  // the arg is boolean
+  if (typeof arg === 'boolean') {
+    return arg === value
+  }
+
+  // the arg is blank or *: Blank => Empty, * => Not Empty
+  if (arg === '' || arg === '*') {
+    // null and undefined are not included in either case
+    if (value === null || value === undefined) {
+      return false
+    }
+    if (typeof value === 'string') {
+      return arg === '' ? value === '' : value !== ''
+    }
+    if (Array.isArray(value)) {
+      return arg === '' ? value.length === 0 : value.length !== 0
+    }
+    return arg !== ''
+  }
+
+  // the arg is alphabetic or number
+  if (_isPureStringOrNumber(arg)) {
+    return arg === value
+  }
+
+  // the arg is array of [] or [*]: [] => Empty, [*] => Not Empty
+  if (arg.startsWith('[') && arg.endsWith(']')) {
+    if (arg === '[]') {
+      return Array.isArray(value) && value.length === 0
+    }
+    if (arg === '[*]') {
+      return Array.isArray(value) && value.length !== 0
+    }
+    return false
+  }
+
+  // the arg is 'operator + string | number'
+  const { operator, value: argValue } = _splitOperator(arg)
+  if (!operator || (argValue !== 0 && !argValue)) {
+    return false
+  }
+  switch (operator) {
+    case '>':
+      return value > argValue
+    case '<':
+      return value < argValue
+    case '!=':
+      return value !== argValue
+    case '>=':
+      return value >= argValue
+    case '<=':
+      return value <= argValue
+    default:
+      return false
   }
-  const [key, _args] = args
-  return data.filter((e) => {
-    return _args.includes(e[key])
-  })
 }
 
+function _isPureStringOrNumber(input) {
+  if (typeof input === 'string') {
+    if (input.startsWith('[') && input.endsWith(']')) {
+      return false
+    }
+    if (/!=|>=|<=|>|</.test(input)) {
+      return false
+    }
+    return true
+  }
+  return !Number.isNaN(input)
+}
 
+function _splitOperator(str) {
+  const operators = ['!=', '>=', '<=', '>', '<']
 
-;// ./lib/models/template/helpers/_filterOne.js
+  const matchedOp = operators.find((op) => str.startsWith(op))
+  if (!matchedOp) return { operator: null, value: null }
+
+  const remaining = str.slice(matchedOp.length)
+
+  // '>Primary' or '<Primary' is invalid
+  if (/^[a-zA-Z]*$/.test(remaining) && matchedOp !== '!=') {
+    return { operator: null, value: null }
+  }
+
+  // if it is a number it is converted to a number
+  const value = (!Number.isNaN(parseFloat(remaining)) && !Number.isNaN(remaining)) ? Number(remaining) : remaining
+
+  return {
+    operator: matchedOp,
+    value
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_filterOne.js
 
 
 
 function _filterOne(data, args) {
-  const list = _filterAll(data, args)
-  if (list.length > 0) {
-    return list[0]
+  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
   }
-  return null
 }
 
 
 
-;// ./lib/models/template/helpers/_get.js
+;// ./lib/models/templateCompiler/helpers/_formatDate.js
 
 
-function _get(data, key, failover = null) {
-  if (data === null || (typeof data === 'undefined') || key === '') {
+function _formatDate(timestamp, format) {
+  if (format.length === 0) {
+    throw new TemplateCompilerException(`_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: format parts must be not empty array`)
+  }
+
+  if (timestamp === null || timestamp === undefined) {
     return null
-    // throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.argumentEmptyException)
   }
 
-  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)
-    }
+  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')
   }
 
-  if (typeof data[key] !== 'undefined') {
-    return data[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(', ')}`
+    )
   }
 
-  return _handleFailover(key, failover)
+  // Build the formatted string using reduce
+  return format.reduce((result, part) => result + (partsMap[part] || part), '')
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_get.js
+
+
+function _get(data, key, failover = null) {
+  try {
+    if (key === null || (typeof key === 'undefined') || key === '') {
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
+    }
+    if (data === null) {
+      return null
+    }
+    if (key.includes('.')) {
+      const parts = key.split('.')
+      if (parts.length > 1) {
+        const first = parts.shift()
+        const remainingKey = parts.join('.')
+        if (typeof data[first] !== 'undefined') {
+          return _get(data[first], remainingKey, failover)
+        }
+        return _handleFailover(key, failover)
+      }
+    }
+    if (typeof data[key] !== 'undefined') {
+      return data[key]
+    }
+    return _handleFailover(key, failover)
+  } catch (e) {
+    throw e
+  }
 }
 
 function _handleFailover(key, failover) {
@@ -1285,108 +1509,396 @@ function _handleFailover(key, failover) {
     return failover
   }
   return null
-  // throw new TemplateException(`Key "${key}" does not exist and no failover`)
+  // throw new TemplateCompilerException(`Key "${key}" does not exist and no failover`)
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_gt.js
+
+
+
+
+function _gt(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_gt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data > expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_gte.js
+
+
+
+
+function _gte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_gte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data >= expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_isEmpty.js
+
+
+
+
+function _isEmpty(data, args) {
+  if (args.length !== 2) {
+    throw new TemplateCompilerException(`_isEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  // if (data === null || (typeof data === 'undefined')) {
+  //   return null
+  // }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
+    return args[0]
+  }
+  return (data === '' || data === null || data === undefined || data.length === 0) ? args[0] : args[1]
 }
 
 
 
-;// ./lib/models/template/helpers/_join.js
+;// ./lib/models/templateCompiler/helpers/_isNotEmpty.js
+
+
+
+
+function _isNotEmpty(data, args) {
+  if (args.length !== 2) {
+    throw new TemplateCompilerException(`_isNotEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  // if (data === null || (typeof data === 'undefined')) {
+  //   return null
+  // }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
+    return args[1]
+  }
+  if (Array.isArray(data) && data.length === 0) {
+    return args[1]
+  }
+  if (typeof data === 'string' && data === '') {
+    return args[1]
+  }
+  if (data === null || data === undefined) {
+    return args[1]
+  }
+  return args[0]
+}
+
+
+;// ./lib/models/templateCompiler/helpers/_join.js
 function _join(data, delimiter) {
-  return data.join(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/template/helpers/_map.js
 
+;// ./lib/models/templateCompiler/helpers/_lt.js
 
 
-function _map(data, args) {
-  if (data === null || (typeof data === 'undefined') || args.length === 0) {
+
+
+function _lt(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
     return null
-    // throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.argumentEmptyException)
   }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data < expected ? args[1] : args[2]
+}
 
-  const result = data.reduce((acc, item) => {
-    if (args.length === 1 && Array.isArray(args[0])) {
-      args = args[0]
-      acc.hasFormat = true
+
+
+;// ./lib/models/templateCompiler/helpers/_lte.js
+
+
+
+
+function _lte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data <= expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_map.js
+
+
+
+function _map(data, args) {
+  try {
+    if (args.length === 0) {
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
     }
-    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 (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
       }
-      if (typeof item[key] !== 'undefined') {
-        return item[key]
+      const list = args.map((key) => {
+        if (key.includes('.')) {
+          const parts = key.split('.')
+          const first = parts[0]
+          parts.shift()
+          const remainingKey = parts.join('.')
+          return _get(item[first], remainingKey)
+        }
+        if (typeof item[key] !== 'undefined') {
+          return item[key]
+        }
+        return null
+      })
+      if (acc.hasFormat) {
+        acc.content.push(list)
+      } else {
+        acc.content = acc.content.concat(list)
       }
-      return null
-      // throw new TemplateException('Key "$key" does not exist')
+      return acc
+    }, {
+      content: [],
+      hasFormat: false
     })
-    if (acc.hasFormat) {
-      acc.content.push(list)
-    } else {
-      acc.content = acc.content.concat(list)
-    }
-    return acc
-  }, {
-    content: [],
-    hasFormat: false
-  })
-  return result.content
+    return result.content
+  } catch (e) {
+    throw e
+  }
 }
 
 
 
-;// ./lib/models/template/helpers/index.js
+;// ./lib/models/templateCompiler/helpers/_neq.js
 
 
 
 
+function _neq(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_neq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data !== expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_toLowerCase.js
+
+
+function _toLowerCase(data, args) {
+  if (args !== undefined) {
+    throw new TemplateCompilerException(`_toLowerCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
+    return null
+  }
+  return String(data).toLowerCase()
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_toUpperCase.js
+
+
+function _toUpperCase(data, args) {
+  if (typeof data !== 'string') {
+    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string: ${data}`)
+  }
+  if (args !== undefined) {
+    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the argument must be empty: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
+    return null
+  }
+  return String(data).toUpperCase()
+}
+
 
 
+;// ./lib/models/templateCompiler/helpers/index.js
 
 
 
-;// ./lib/models/template/template.js
 
 
 
 
-class Template {
-  constructor({ data }) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./lib/models/templateCompiler/templateCompiler.js
+
+
+
+
+class TemplateCompiler {
+  constructor(data) {
     this.data = data
   }
+  static init(options) {
+    return new this(options)
+  }
+  static initFromArray(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.map((a) => this.init(a))
+    }
+    return []
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+  static concatIf(data, args) {
+    return _concatIf(data, args)
+  }
   static eq(data, args) {
     return _eq(data, args)
   }
+
+  static filterAll(data, args) {
+    return _filterAll(data, args)
+  }
+
+  static formatDate(data, args) {
+    return _formatDate(data, args)
+  }
+  
   static get(data, key, failover = null) {
     return _get(data, key, failover)
   }
+  static gt(data, args) {
+    return _gt(data, args)
+  }
+  static gte(data, args) {
+    return _gte(data, args)
+  }
+  static isEmpty(data, args) {
+    return _isEmpty(data, args)
+  }
+  static isNotEmpty(data, args) {
+    return _isNotEmpty(data, args)
+  }
   static join(data, separator = '') {
     return _join(data, separator)
   }
+  static lt(data, args) {
+    return _lt(data, args)
+  }
+  static lte(data, args) {
+    return _lte(data, args)
+  }
   static map(data, args = []) {
     return _map(data, args)
   }
+  static neq(data, args) {
+    return _neq(data, args)
+  }
+  static 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_EJS : TAGS_HANDLEBAR
+    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) {
-      const functionList = _parseFunction(match[1], _FN_NAMES)
-      return functionList.reduce((acc, fn) => {
-        return _callFunction(acc, fn.name, fn.args)
-      }, this.data)
+      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 TemplateException(TEMPLATE_EXCEPTION_TYPE.invalu)
+    throw new TemplateCompilerException(`TemplateCompiler engine error: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.invalidRegExpException}`)
   }
 }
 
@@ -1410,7 +1922,7 @@ function _parseFunction(expression, existFunctionNames) {
           args: paramList
         })
       } else {
-        throw new TemplateException(`${functionName} is not a valid function`)
+        throw new TemplateCompilerException(`${functionName} is not a valid function`)
       }
     }
     return acc
@@ -1454,12 +1966,18 @@ function _parseSinglePart(input) {
       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 (_input.startsWith('[') && _input.endsWith(']')) {
+      const listContent = _input.substring(1, _input.length - 1).trim()
       if (listContent !== '') {
         return listContent.split(',').map((item) => {
-          return item.trim().replaceAll('"', '') // 去除可能的双引号
+          return _toBasicType(item.trim())
         })
       }
       return []
@@ -1469,66 +1987,86 @@ function _parseSinglePart(input) {
   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 (!Number.isNaN(input) && !Number.isNaN(Number.parseFloat(input))) {
+    return Number(input)
+  }
+  return input
+}
+
 function _callFunction(data, functionName, parameters) {
-  let failover
-  switch (functionName) {
-    case 'get':
-      if (parameters.length > 2) {
-        throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.argumentFormatException)
-      }
-      if (parameters.length === 2) {
-        failover = parameters[parameters.length - 1]
-      }
-      return _get(data, parameters[0], failover)
-    case 'map':
-      return _map(data, parameters)
-    case 'join':
-      return _join(data, parameters[0])
-    // case 'concatIf':
-    //   if (parameters.length != 3) {
-    //     throw const TemplateException(TemplateExceptionType.argumentFormatException);
-    //   }
-    //   var condition = parameters.first;
-    //   var success = parameters[1];
-    //   var failover = parameters[2];
-    //   return _concatIf(data, condition, success, failover);
-    case 'filterOne':
-      return _filterOne(data, parameters)
-    case 'filterAll':
-      return _filterAll(data, parameters)
-    // case 'formatDate':
-    //   if (parameters is List<String>) {
-    //     return _formatDate(data, parameters);
-    //   }
-    //   throw const TemplateException(TemplateExceptionType.argumentFormatException);
-    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`)
+  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`)
+    }
+  } catch (e) {
+    throw e
   }
 }
 
 
 
-;// ./lib/models/template/index.js
+;// ./lib/models/templateCompiler/index.js