@questwork/q-utilities 0.1.18 → 0.1.19

package/dist/index.min.cjs

@@ -0,0 +1,3749 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  ApiResponse: () => (/* reexport */ ApiResponse),
+  AwsStsS3Client: () => (/* reexport */ AwsStsS3Client),
+  KeyValueObject: () => (/* reexport */ KeyValueObject),
+  Metadata: () => (/* reexport */ Metadata),
+  PushEnvelope: () => (/* reexport */ PushEnvelope),
+  QMeta: () => (/* reexport */ QMeta),
+  Repo: () => (/* reexport */ Repo),
+  Service: () => (/* reexport */ Service),
+  TemplateCompiler: () => (/* reexport */ TemplateCompiler),
+  TenantAwareEntity: () => (/* reexport */ TenantAwareEntity),
+  TrackedEntity: () => (/* reexport */ TrackedEntity),
+  UniqueKeyGenerator: () => (/* reexport */ UniqueKeyGenerator),
+  authorize: () => (/* reexport */ authorize),
+  calculateAge: () => (/* reexport */ calculateAge),
+  changeCreatorOwner: () => (/* reexport */ changeCreatorOwner),
+  concatStringByArray: () => (/* reexport */ concatStringByArray),
+  convertString: () => (/* reexport */ convertString),
+  escapeRegex: () => (/* reexport */ escapeRegex),
+  expressHelper: () => (/* reexport */ expressHelper),
+  extractEmails: () => (/* reexport */ extractEmails),
+  formatDate: () => (/* reexport */ formatDate),
+  generalPost: () => (/* reexport */ generalPost),
+  getValidation: () => (/* reexport */ getValidation),
+  getValueByKeys: () => (/* reexport */ getValueByKeys_getValueByKeys),
+  groupArrayByKey: () => (/* reexport */ groupArrayByKey),
+  init: () => (/* reexport */ init),
+  initFromArray: () => (/* reexport */ initFromArray),
+  initOnlyValidFromArray: () => (/* reexport */ initOnlyValidFromArray),
+  makeApiResponse: () => (/* reexport */ makeApiResponse),
+  makeService: () => (/* reexport */ makeService),
+  mergeArraysByKey: () => (/* reexport */ mergeArraysByKey),
+  objectHelper: () => (/* reexport */ objectHelper),
+  pReduce: () => (/* reexport */ pReduce),
+  padZeros: () => (/* reexport */ padZeros),
+  replacePlaceholders: () => (/* reexport */ replacePlaceholders),
+  sanitizeText: () => (/* reexport */ sanitizeText),
+  shuffleArray: () => (/* reexport */ shuffleArray),
+  stringFormatter: () => (/* reexport */ stringFormatter),
+  stringHelper: () => (/* reexport */ stringHelper),
+  tenantPlugin: () => (/* reexport */ tenantPlugin),
+  trackingPlugin: () => (/* reexport */ trackingPlugin)
+});
+
+;// ./lib/helpers/authorize/authorize.js
+function authorize({ allowCoordinator, allowOwner, query = {}, required, user }) {
+  if (!user) {
+    throw new Error('Require login.')
+  }
+  if (!user.permission) {
+    // throw new Error('You do not have any permission.')
+  }
+  const scopes = user.permission.getScopes(required || {}) || []
+  if (!scopes || scopes.length === 0) {
+    // throw new Error('You are not allowed in this scope.')
+  }
+  if (!scopes.includes('*')) {
+    query.tenantCode = user.tenantCode
+  }
+  if (!scopes.includes('TENANT')) {
+    query.eventShortCode = user.eventShortCode
+  }
+  // if (!scopes.includes('EVENT')) {
+  //   query.eventRegistrationCode = user.eventRegistrationCode
+  // }
+  if (allowCoordinator) {
+    if (query.registrationGroupCode && user.myManagedRegistrationGroupCodes.includes(query.registrationGroupCode)) {
+      query.__ALLOW_COORDINATOR = true
+    } else {
+        if (!scopes.includes('EVENT')) {
+          query.eventRegistrationCode = user.eventRegistrationCode
+        }
+    }
+  } else {
+      if (!scopes.includes('EVENT')) {
+        query.eventRegistrationCode = user.eventRegistrationCode
+      }
+  }
+  if (allowOwner) {
+    query.__ALLOW_OWNER = true
+  }
+  // not good, just use it as example
+  if (user.hasExcludedFields) {
+    query.__EXCLUDED_FIELDS = user.getExcludedFields(required)
+  }
+  query.__LOGIN_SUBJECT_CODE = user.loginSubjectCode
+  return query
+}
+
+;// ./lib/helpers/authorize/index.js
+
+
+;// ./lib/helpers/calculateAge/calculateAge.js
+function calculateAge(timestamp, reference) {
+  const birthDate = new Date(timestamp)
+  const refDate = reference ? new Date(reference) : new Date()
+  // Validate inputs
+  if (isNaN(birthDate.getTime())) {
+    return null
+  }
+  if (isNaN(refDate.getTime())) {
+    return null
+  }
+  if (birthDate > refDate) {
+    return null
+  }
+
+  // Calculate raw difference
+  let age = refDate.getFullYear() - birthDate.getFullYear();
+  const monthDiff = refDate.getMonth() - birthDate.getMonth();
+  
+  // Adjust if birthday hasn't occurred yet this year
+  if (monthDiff < 0 || (monthDiff === 0 && refDate.getDate() < birthDate.getDate())) {
+    age--
+  }
+  
+  return age
+}
+
+;// ./lib/helpers/calculateAge/index.js
+
+
+;// ./lib/helpers/changeCreatorOwner/changeCreatorOwner.js
+function changeCreatorOwner(that, { source, target }) {
+  if (that.meta) {
+    if (!that.meta.creator || that.meta.creator === source.getId()) {
+      that.meta.creator = target.getId()
+    }
+    if (!that.meta.owner || that.meta.owner === source.getId()) {
+      that.meta.owner = target.getId()
+    }
+  } else {
+    if (!that.creator || that.creator === source.getId()) {
+      that.creator = target.getId()
+    }
+    if (!that.owner || that.owner === source.getId()) {
+      that.owner = target.getId()
+    }
+  }
+  return that
+}
+
+;// ./lib/helpers/changeCreatorOwner/index.js
+
+
+;// ./lib/helpers/getValidation/getValidation.js
+function getValidation(rule, data, getDataByKey, KeyValueObject) {
+  if (!rule) {
+    return true
+  }
+  if (typeof getDataByKey !== 'function' || (KeyValueObject && typeof KeyValueObject !== 'function')) {
+    return false
+  }
+  const { key = '', value, placeholder, keyValuePath = '' } = rule
+  const [valueAttribute] = Object.keys(value)
+
+  if (!key && typeof placeholder === 'undefined') {
+    switch (valueAttribute) {
+      case '$and': {
+        return value['$and'].reduce((acc, item) => (acc && getValidation(item, data, getDataByKey, KeyValueObject)), true)
+      }
+      case '$or': {
+        return value['$or'].reduce((acc, item) => (acc || getValidation(item, data, getDataByKey, KeyValueObject)), false)
+      }
+      default:
+        return false
+    }
+  }
+  let rowValue = typeof placeholder === 'undefined' ? getDataByKey(key, data) : placeholder
+
+  // if KeyValue object
+  if (keyValuePath) {
+    const rowValueData = KeyValueObject.toObject(rowValue)
+    rowValue = getDataByKey(keyValuePath, rowValueData)
+  }
+
+  switch (valueAttribute) {
+    case '$empty': {
+      const isEmpty = rowValue === null || rowValue === undefined
+      return isEmpty === value['$empty']
+    }
+    case '$eq': {
+      return rowValue === value['$eq']
+    }
+    case '$gt': {
+      return rowValue > value['$gt']
+    }
+    case '$gte': {
+      return rowValue >= value['$gte']
+    }
+    case '$hasOverlap': {
+      return _hasOverlap(rowValue, value['$hasOverlap'])
+    }
+    case '$lt': {
+      return rowValue < value['$lt']
+    }
+    case '$lte': {
+      return rowValue <= value['$lte']
+    }
+    case '$in': {
+      if (Array.isArray(rowValue)) {
+        return !!rowValue.find((e) => (value['$in'].includes(e)))
+      }
+      if (typeof rowValue !== 'object') {
+        return !!value['$in'].includes(rowValue)
+      }
+      return false
+    }
+    case '$inValue': {
+      const result = getDataByKey(value['$inValue'], data)
+      const _value = Array.isArray(result) ? result : []
+      if (Array.isArray(rowValue)) {
+        return !!rowValue.find((e) => (_value.includes(e)))
+      }
+      if (typeof rowValue === 'string') {
+        return !!_value.includes(rowValue)
+      }
+      return false
+    }
+    case '$ne': {
+      return rowValue !== value['$ne']
+    }
+    case '$notIn': {
+      if (Array.isArray(rowValue)) {
+        return !rowValue.find((e) => (value['$notIn'].includes(e)))
+      }
+      if (typeof rowValue !== 'object') {
+        return !value['$notIn'].includes(rowValue)
+      }
+      return false
+    }
+    case '$intervalTimeGt': {
+      const now = new Date().getTime()
+      const timestamp = new Date(rowValue).getTime()
+      return (now - timestamp) > value['$intervalTimeGt']
+    }
+    case '$intervalTimeLt': {
+      const now = new Date().getTime()
+      const timestamp = new Date(rowValue).getTime()
+      return (now - timestamp) < value['$intervalTimeLt']
+    }
+    case '$isToday': {
+      const currentDate = new Date()
+      const start = currentDate.setHours(0,0,0,0)
+      const end = currentDate.setHours(23,59,59,59)
+      const dateValue = new Date(rowValue).getTime()
+      return (start <= dateValue && end >= dateValue) === value['$isToday']
+    }
+    case '$notInValue': {
+      const result = getDataByKey(value['$notInValue'], data)
+      const _value = Array.isArray(result) ? result : []
+      if (Array.isArray(rowValue)) {
+        return !rowValue.find((e) => (_value.includes(e)))
+      }
+      if (typeof rowValue !== 'object') {
+        return !_value.includes(rowValue)
+      }
+      return false
+    }
+    case '$range': {
+      const [min, max] = value['$range']
+      if (typeof min === 'number' && typeof max === 'number' && rowValue >= min && rowValue <= max) {
+        return true
+      }
+      return false
+    }
+    default:
+      return false
+  }
+
+}
+
+function _hasOverlap(item1, item2) {
+  let arr1 = item1
+  let arr2 = item2
+  if (typeof arr1 === 'string') {
+    arr1 = arr1.split(',')
+  }
+  if (typeof arr2 === 'string') {
+    arr2 = arr2.split(',')
+  }
+  const set1 = new Set(arr1)
+  return arr2.find((i) => (set1.has(i)))
+}
+
+/* harmony default export */ const getValidation_getValidation = ({
+  getValidation
+});
+
+
+;// ./lib/helpers/getValidation/index.js
+
+
+;// ./lib/helpers/formatDate/formatDate.js
+
+function formatDate(date, format) {
+  const _date = date && date instanceof Date ? date : new Date(date)
+  const dayMapChi = ['日','一','二','三','四','五','六']
+  const dayMapEng = ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']
+  const dayMapEngShort = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
+  const _format = format || 'YYYY/MM/DD hh:mm'
+  const e = _date.getDay()
+  const ee = dayMapEngShort[e]
+  const eee = dayMapChi[e]
+  const eeee = dayMapEng[e]
+  const y = _date.getFullYear()
+  const m = _date.getMonth() + 1
+  const d = _date.getDate()
+  const h = _date.getHours()
+  const mm = _date.getMinutes()
+  const s = _date.getSeconds()
+
+  return _format.replace('YYYY', y)
+    .replace('MM', padding(m))
+    .replace('MM', padding(m))
+    .replace('DD', padding(d))
+    .replace('hh', padding(h))
+    .replace('mm', padding(mm))
+    .replace('ss', padding(s))
+    .replace('M', m)
+    .replace('D', d)
+    .replace('h', h)
+    .replace('m', mm)
+    .replace('s', s)
+    .replace('EEEE', padding(eeee))
+    .replace('EEE', padding(eee))
+    .replace('EE', padding(ee))
+    .replace('E', padding(e))
+}
+
+function padding(m) {
+  return m < 10 ? `0${m}` : m
+}
+
+
+/* harmony default export */ const formatDate_formatDate = ({
+  formatDate
+});
+
+
+
+;// ./lib/helpers/formatDate/index.js
+
+
+;// ./lib/helpers/getValueByKeys/getValueByKeys.js
+// keys can be array or object or string
+function getValueByKeys_getValueByKeys(keys, data) {
+  let _keys = keys
+  let _data = data
+  if (typeof keys === 'string') {
+    _keys = _keys.split('.')
+  }
+  if (!Array.isArray(keys) && typeof keys === 'object') {
+    const { keys: keyArr, obj } = keys
+    _keys = keyArr
+    _data = obj
+  }
+  if (_keys.length === 0) {
+    return _data
+  }
+  const firstKey = _keys.shift()
+  if (_data && Object.prototype.hasOwnProperty.call(_data, firstKey)) {
+    return getValueByKeys_getValueByKeys(_keys, _data[firstKey])
+  }
+  if (_data && firstKey) {
+    if (_keys.length > 0) {
+      return getValueByKeys_getValueByKeys(_keys, _data[firstKey])
+    }
+    return _data[firstKey]
+  }
+  return _data
+
+}
+/* harmony default export */ const getValueByKeys = ({
+  getValueByKeys: getValueByKeys_getValueByKeys
+});
+
+
+;// ./lib/helpers/getValueByKeys/index.js
+
+
+;// ./lib/models/templateCompiler/templateCompilerException.js
+const TEMPLATE_COMPILER_EXCEPTION_TYPE = {
+  argumentEmptyException: 'Argument is empty',
+  argumentFormatException: 'Incorrect number or format of argument',
+  invalidFuntionException: 'Function Name is invalid',
+  invalidRegExpException: 'Invalid regular expression',
+  isNotAFunctionException: 'Is not a function',
+  notExistException: 'Key does not exist',
+  resultEmptyException: 'Result is empty',
+  resultMoreThanOneException: 'More than one result'
+}
+
+class TemplateCompilerException extends Error {
+  constructor(message) {
+    super(message)
+    this.message = message
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/constants.js
+const _EMPTY = '_EMPTY'
+const _FN_NAMES = [
+  'concatIf',
+  'divide',
+  'eq',
+  'exec',
+  'filterAll',
+  'filterOne',
+  'formatDate',
+  'get',
+  'gt',
+  'gte',
+  'isEmpty',
+  'isNotEmpty',
+  'join',
+  'lt',
+  'lte',
+  'map',
+  'neq',
+  'removeHtml',
+  'toLowerCase',
+  'toUpperCase',
+]
+const _HIDE = '_HIDE'
+const _NOT_EMPTY = '_NOT_EMPTY'
+const _SELF = '_SELF'
+const TAGS_EJS = ['<%=', '%>']
+const TAGS_HANDLEBAR = ['{{', '}}']
+
+
+
+;// ./lib/models/templateCompiler/helpers/_concatIf.js
+
+
+
+
+function _concatIf(data, args) {
+  if (typeof data !== 'string') {
+    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string :${data.join(', ')}`)
+  }
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  const [condition, success, failover] = args
+  const validConditions = [_EMPTY, _NOT_EMPTY]
+  if (validConditions.includes(condition) || success.length !== 2) {
+    throw new TemplateCompilerException(`concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException}: ${condition}, ${success}`)
+  }
+  if (data === '' && failover.includes(_HIDE)) {
+    return ''
+  }
+  if (data !== '' && (data !== null || data !== undefined) && failover.includes(_HIDE)) {
+    return `${success[0]}${data}${success[success.length - 1]}`
+  }
+  return failover
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_divide.js
+function _divide(value, divisor) {
+  try {
+    if (Number.isNaN(value)) {
+      return value
+    }
+    return (value / divisor)
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_eq.js
+
+
+
+
+function _eq(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`eq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data === expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_exec.js
+function _exec(data, args) {
+  try {
+    const [methodName, ..._args] = args
+    return data[methodName](..._args)
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_filterAll.js
+
+
+
+// const DELIMITER = '~~~'
+
+function _filterAll(data, args) {
+  try {
+    if (!Array.isArray(args) || args.length === 0) {
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
+    }
+    if (!Array.isArray(data) || data.length === 0) {
+      return []
+    }
+    if (typeof data[0] === 'object') {
+      return _existObject(data, args)
+    }
+    if (typeof data[0] === 'string' || typeof data[0] === 'number') {
+      return _exist(data, args)
+    }
+    return []
+  } catch (e) {
+    throw e
+  }
+}
+
+function _exist(data, args) {
+  const _args = args.flat()
+  return data.filter((e) => _args.some((arg) => _performOperation(arg, e)))
+}
+
+function _existObject(data, args) {
+  if (args.length === 1) {
+    const arg = args[0]
+    return data.filter((e) => {
+      if (arg.includes('.')) {
+        return getValueByKeys_getValueByKeys(arg.split('.'), e)
+      }
+      return Object.prototype.hasOwnProperty.call(e, arg)
+    })
+  }
+
+  if (args.length > 2) {
+    let res = data
+    for (let i = 0; i < args.length; i += 2) {
+      const group = [args[i], args[i + 1]]
+      res = _existObject(res, group)
+    }
+    return res
+  }
+
+  const [key, ..._argsArr] = args
+  const _args = _argsArr.flat()
+  return data.filter((e) => {
+    const value = key.includes('.') ? getValueByKeys_getValueByKeys(key.split('.'), e) : e[key]
+    return _args.some((arg) => _performOperation(arg, value))
+  })
+}
+
+function _performOperation(arg, value) {
+  // the arg is undefined
+  if (arg === undefined && value === undefined) return true
+
+  // the arg is null
+  if (arg === null && value === null) return true
+
+  // the arg is boolean
+  if (typeof arg === 'boolean') {
+    return arg === value
+  }
+
+  // the arg is blank or *: Blank => Empty, * => Not Empty
+  if (arg === '' || arg === '*') {
+    // null and undefined are not included in either case
+    if (value === null || value === undefined) {
+      return false
+    }
+    if (typeof value === 'string') {
+      return arg === '' ? value === '' : value !== ''
+    }
+    if (Array.isArray(value)) {
+      return arg === '' ? value.length === 0 : value.length !== 0
+    }
+    return arg !== ''
+  }
+
+  // the arg is alphabetic or number
+  if (_isPureStringOrNumber(arg)) {
+    return arg === value
+  }
+
+  // the arg is array of [] or [*]: [] => Empty, [*] => Not Empty
+  if (arg.startsWith('[') && arg.endsWith(']')) {
+    if (arg === '[]') {
+      return Array.isArray(value) && value.length === 0
+    }
+    if (arg === '[*]') {
+      return Array.isArray(value) && value.length !== 0
+    }
+    return false
+  }
+
+  // the arg is 'operator + string | number'
+  const { operator, value: argValue } = _splitOperator(arg)
+  if (!operator || (argValue !== 0 && !argValue)) {
+    return false
+  }
+  switch (operator) {
+    case '>':
+      return value > argValue
+    case '<':
+      return value < argValue
+    case '!=':
+      return value !== argValue
+    case '>=':
+      return value >= argValue
+    case '<=':
+      return value <= argValue
+    default:
+      return false
+  }
+}
+
+function _isPureStringOrNumber(input) {
+  if (typeof input === 'string') {
+    if (input.startsWith('[') && input.endsWith(']')) {
+      return false
+    }
+    if (/!=|>=|<=|>|</.test(input)) {
+      return false
+    }
+    return true
+  }
+  return !Number.isNaN(input)
+}
+
+function _splitOperator(str) {
+  const operators = ['!=', '>=', '<=', '>', '<']
+
+  const matchedOp = operators.find((op) => str.startsWith(op))
+  if (!matchedOp) return { operator: null, value: null }
+
+  const remaining = str.slice(matchedOp.length)
+
+  // '>Primary' or '<Primary' is invalid
+  if (/^[a-zA-Z]*$/.test(remaining) && matchedOp !== '!=') {
+    return { operator: null, value: null }
+  }
+
+  // if it is a number it is converted to a number
+  const value = (!Number.isNaN(parseFloat(remaining)) && !Number.isNaN(remaining)) ? Number(remaining) : remaining
+
+  return {
+    operator: matchedOp,
+    value
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_filterOne.js
+
+
+
+function _filterOne(data, args) {
+  try {
+    const list = _filterAll(data, args)
+    if (list.length === 1) {
+      return list[0]
+    }
+    if (list.length === 0) {
+      return null
+    }
+    throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.resultMoreThanOneException)
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_formatDate.js
+
+
+function _formatDate(timestamp, format) {
+  if (format.length === 0) {
+    throw new TemplateCompilerException(`_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: format parts must be not empty array`)
+  }
+
+  if (timestamp === null || timestamp === undefined) {
+    return null
+  }
+
+  const date = new Date(timestamp)
+
+  const partsMap = {
+    yyyy: String(date.getFullYear()),
+    mm: String(date.getMonth() + 1).padStart(2, '0'),
+    dd: String(date.getDate()).padStart(2, '0')
+  }
+
+  // Check for invalid format tokens
+  const validTokens = ['yyyy', 'mm', 'dd']
+  const invalidTokens = format.filter((part) => part.length > 1 && !validTokens.includes(part))
+
+  if (invalidTokens.length > 0) {
+    throw new TemplateCompilerException(
+      `_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the format type is not valid: ${format.join(', ')}`
+    )
+  }
+
+  // Build the formatted string using reduce
+  return format.reduce((result, part) => result + (partsMap[part] || part), '')
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_get.js
+
+
+function _get(data, key, failover = null) {
+  try {
+    if (key === null || (typeof key === 'undefined') || key === '') {
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
+    }
+    if (data === null) {
+      return null
+    }
+    if (key.includes('.')) {
+      const parts = key.split('.')
+      if (parts.length > 1) {
+        const first = parts.shift()
+        const remainingKey = parts.join('.')
+        if (typeof data[first] !== 'undefined') {
+          return _get(data[first], remainingKey, failover)
+        }
+        return _handleFailover(key, failover)
+      }
+    }
+    if (typeof data[key] !== 'undefined') {
+      return data[key]
+    }
+    return _handleFailover(key, failover)
+  } catch (e) {
+    throw e
+  }
+}
+
+function _handleFailover(key, failover) {
+  if (failover !== null) {
+    return failover
+  }
+  return null
+  // throw new TemplateCompilerException(`Key "${key}" does not exist and no failover`)
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_gt.js
+
+
+
+
+function _gt(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_gt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data > expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_gte.js
+
+
+
+
+function _gte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_gte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data >= expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_isEmpty.js
+
+
+
+
+function _isEmpty(data, args) {
+  if (args.length !== 2) {
+    throw new TemplateCompilerException(`_isEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  // if (data === null || (typeof data === 'undefined')) {
+  //   return null
+  // }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
+    return args[0]
+  }
+  return (data === '' || data === null || data === undefined || data.length === 0) ? args[0] : args[1]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_isNotEmpty.js
+
+
+
+
+function _isNotEmpty(data, args) {
+  if (args.length !== 2) {
+    throw new TemplateCompilerException(`_isNotEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  // if (data === null || (typeof data === 'undefined')) {
+  //   return null
+  // }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
+    return args[1]
+  }
+  if (Array.isArray(data) && data.length === 0) {
+    return args[1]
+  }
+  if (typeof data === 'string' && data === '') {
+    return args[1]
+  }
+  if (data === null || data === undefined) {
+    return args[1]
+  }
+  return args[0]
+}
+
+
+;// ./lib/models/templateCompiler/helpers/_join.js
+function _join(data, delimiter) {
+  try {
+    if (data.length === 0) return ''
+    if (data.length === 1) return _stringifyObject(data[0])
+    return data.map((item) => _stringifyObject(item)).join(delimiter)
+  } catch (e) {
+    throw e
+  }
+}
+
+function _stringifyObject(obj) {
+  return JSON.stringify(obj).replace(/"([^"]+)":/g, '$1: ').replace(/"([^"]+)"/g, '$1').replace(/,/g, ', ')
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_lt.js
+
+
+
+
+function _lt(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data < expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_lte.js
+
+
+
+
+function _lte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data <= expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_map.js
+
+
+
+function _map(data, args) {
+  try {
+    if (args.length === 0) {
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
+    }
+    if (data === null || (typeof data === 'undefined')) {
+      return null
+    }
+
+    const result = data.reduce((acc, item) => {
+      if (args.length === 1 && Array.isArray(args[0])) {
+        args = args[0]
+        acc.hasFormat = true
+      }
+      const list = args.map((key) => {
+        if (key.includes('.')) {
+          const parts = key.split('.')
+          const first = parts[0]
+          parts.shift()
+          const remainingKey = parts.join('.')
+          return _get(item[first], remainingKey)
+        }
+        if (typeof item[key] !== 'undefined') {
+          return item[key]
+        }
+        return null
+      })
+      if (acc.hasFormat) {
+        acc.content.push(list)
+      } else {
+        acc.content = acc.content.concat(list)
+      }
+      return acc
+    }, {
+      content: [],
+      hasFormat: false
+    })
+    return result.content
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_neq.js
+
+
+
+
+function _neq(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_neq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data !== expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_removeHtml.js
+
+
+function _removeHtml(html, args) {
+  if (html === null || html === undefined) {
+    return null
+  }
+  if (!Array.isArray(args)) {
+    throw new TemplateCompilerException(`_removeHtml: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: args parts must be array`)
+  }
+
+  return _htmlToPlainText(html, args[0])
+}
+
+function _htmlToPlainText(html, delimiter = '\n') {
+  if (typeof delimiter !== 'string') {
+    delimiter = '\n'; // Fallback to default if not a string
+  }
+
+  // First decode HTML entities and normalize whitespace
+  const decodedHtml = html
+    .replace(/&nbsp;/g, ' ')
+    .replace(/\s+/g, ' ');  // Collapse all whitespace to single spaces
+
+  // Process HTML tags
+  let text = decodedHtml
+    // Replace block tags with temporary marker (~~~)
+    .replace(/<\/?(p|div|h[1-6]|ul|ol|li|pre|section|article|table|tr|td|th)(\s[^>]*)?>/gi, '~~~')
+    // Replace <br> tags with temporary marker (~~~)
+    .replace(/<br\s*\/?>/gi, '~~~')
+    // Remove all other tags
+    .replace(/<[^>]+>/g, '')
+    // Convert markers to specified delimiter
+    .replace(/~~~+/g, delimiter)
+    // Trim and clean whitespace
+    .trim();
+
+  // Special handling for empty delimiter
+  if (delimiter === '') {
+    // Collapse all whitespace to single space
+    text = text.replace(/\s+/g, ' ');
+  } else {
+
+
+    // Collapse multiple delimiters to single
+    text = text.replace(new RegExp(`${escapeRegExp(delimiter)}+`, 'g'), delimiter);
+    // Remove leading/trailing delimiters
+    text = text.replace(new RegExp(`^${escapeRegExp(delimiter)}|${escapeRegExp(delimiter)}$`, 'g'), '');
+  }
+
+  return text;
+}
+
+
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_toLowerCase.js
+
+
+function _toLowerCase(data, args) {
+  if (args !== undefined) {
+    throw new TemplateCompilerException(`_toLowerCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
+    return null
+  }
+  return String(data).toLowerCase()
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_toUpperCase.js
+
+
+function _toUpperCase(data, args) {
+  if (typeof data !== 'string') {
+    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string: ${data}`)
+  }
+  if (args !== undefined) {
+    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the argument must be empty: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
+    return null
+  }
+  return String(data).toUpperCase()
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./lib/models/templateCompiler/templateCompiler.js
+
+
+
+
+class TemplateCompiler {
+  constructor(data) {
+    this.data = data
+  }
+  static init(options) {
+    return new this(options)
+  }
+  static initFromArray(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.map((a) => this.init(a))
+    }
+    return []
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+  static concatIf(data, args) {
+    return _concatIf(data, args)
+  }
+  static divide(data, args) {
+    return _divide(data, args)
+  }
+  static eq(data, args) {
+    return _eq(data, args)
+  }
+
+  static filterAll(data, args) {
+    return _filterAll(data, args)
+  }
+
+  static formatDate(data, args) {
+    return _formatDate(data, args)
+  }
+  static get(data, key, failover = null) {
+    return _get(data, key, failover)
+  }
+  static gt(data, args) {
+    return _gt(data, args)
+  }
+  static gte(data, args) {
+    return _gte(data, args)
+  }
+  static isEmpty(data, args) {
+    return _isEmpty(data, args)
+  }
+  static isNotEmpty(data, args) {
+    return _isNotEmpty(data, args)
+  }
+  static join(data, separator = '') {
+    return _join(data, separator)
+  }
+  static lt(data, args) {
+    return _lt(data, args)
+  }
+  static lte(data, args) {
+    return _lte(data, args)
+  }
+  static map(data, args = []) {
+    return _map(data, args)
+  }
+  static neq(data, args) {
+    return _neq(data, args)
+  }
+  static removeHtml(data, args) {
+    return _removeHtml(data, args)
+  }
+  static toLowerCase(data, args) {
+    return _toLowerCase(data, args)
+  }
+  static toUpperCase(data, args) {
+    return _toUpperCase(data, args)
+  }
+  static parseFunction(expression) {
+    return _parseFunction(expression, _FN_NAMES)
+  }
+  static parseParams(parameters) {
+    return _parseParams(parameters)
+  }
+
+  pipe(expression = '') {
+    this.delimiters = expression.substring(0, 2) === '{{' ? TAGS_HANDLEBAR : TAGS_EJS
+    const regex = new RegExp(`${this.delimiters[0]}\\s(.*?)\\s${this.delimiters[1]}`)
+    const match = expression.match(regex)
+    if (match !== null) {
+      try {
+        const functionList = _parseFunction(match[1], _FN_NAMES)
+        return functionList.reduce((acc, fn) => {
+          return _callFunction(acc, fn.name, fn.args)
+        }, this.data)
+      } catch (e) {
+        throw new TemplateCompilerException(`TemplateCompiler engine error: ${e.message}`)
+      }
+    }
+    throw new TemplateCompilerException(`TemplateCompiler engine error: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.invalidRegExpException}`)
+  }
+}
+
+function _parseFunction(expression, existFunctionNames) {
+  const regExp = new RegExp(/(\w+)\(([^)]*)\)/)
+  let parts
+  if (expression.includes('|')) {
+    parts = expression.split('|')
+  } else {
+    parts = [expression]
+  }
+  return parts.reduce((acc, part) => {
+    const match = part.match(regExp)
+    if (match !== null) {
+      const functionName = match[1]
+      const parameters = match[2]
+      const paramList = _parseParams(parameters)
+      if (existFunctionNames.includes(functionName)) {
+        acc.push({
+          name: functionName,
+          args: paramList
+        })
+      } else {
+        throw new TemplateCompilerException(`${functionName} is not a valid function`)
+      }
+    }
+    return acc
+  }, [])
+}
+
+function _parseParams(parameters) {
+  const _parameters = parameters.trim()
+  const regExp = new RegExp(/^[^\w\d\s]+$/)
+  const match = _parameters.match(regExp)
+  if (match !== null) {
+    return [_parameters.substring(1, _parameters.length - 1)]
+  }
+  if (_parameters.includes(',')) {
+    // 用正则表达式匹配逗号，但忽略方括号中的逗号
+    const parts = _splitIgnoringBrackets(_parameters)
+    return parts.map((part) => _parseSinglePart(part))
+  }
+  return [_parseSinglePart(_parameters)]
+}
+
+function _splitIgnoringBrackets(input) {
+  const regExp2 = new RegExp(/^\d+(\.\d+)?$/)
+  const regExp = new RegExp(/(?![^\[]*\])\s*,\s*/)
+  const parts = input.split(regExp)
+  return parts.map((part) => {
+    const _part = part.trim()
+    if (_part !== '' && !!_part.match(regExp2)) {
+      // 如果是数字，转换为 num 类型
+      return Number.isNaN(_part) ? _part : parseInt(_part, 10)
+    }
+    // 否则当作字符串处理
+    return _part
+  })
+}
+
+function _parseSinglePart(input) {
+  if (typeof input === 'string') {
+    if (input.startsWith('"') && input.endsWith('"')) {
+      // 去掉双引号，返回
+      return input.substring(1, input.length - 1)
+    }
+    if (input.startsWith("'") && input.endsWith("'")) {
+      // 去掉双引号，返回
+      return input.substring(1, input.length - 1)
+    }
+
+    const _input = _toBasicType(input)
+
+    if (typeof _input !== 'string') {
+      return _input
+    }
+
+    // 如果是一个列表形式（例如 ["p", "d"] 或 [p, d]）
+    if (_input.startsWith('[') && _input.endsWith(']')) {
+      const listContent = _input.substring(1, _input.length - 1).trim()
+      if (listContent !== '') {
+        return listContent.split(',').map((item) => {
+          return _toBasicType(item.trim())
+        })
+      }
+      return []
+    }
+    return input
+  }
+  return input
+}
+
+function _toBasicType(input) {
+  if (input.startsWith('"') && input.endsWith('"')) {
+    // 去掉双引号，返回
+    return input.substring(1, input.length - 1)
+  }
+  if (input.startsWith("'") && input.endsWith("'")) {
+    // 去掉双引号，返回
+    return input.substring(1, input.length - 1)
+  }
+  if (input === 'true') {
+    return true
+  }
+  if (input === 'false') {
+    return false
+  }
+  if (input === 'undefined') {
+    return undefined
+  }
+  if (input === 'null') {
+    return null
+  }
+  if (!Number.isNaN(input) && !Number.isNaN(Number.parseFloat(input))) {
+    return Number(input)
+  }
+  return input
+}
+
+function _callFunction(data, functionName, parameters) {
+  try {
+    let failover
+    switch (functionName) {
+      case 'concatIf':
+        return _concatIf(data, parameters)
+      case 'divide':
+        return _divide(data, parameters)
+      case 'eq':
+        return _eq(data, parameters)
+      case 'exec':
+        return _exec(data, parameters)
+      case 'filterAll':
+        return _filterAll(data, parameters)
+      case 'filterOne':
+        return _filterOne(data, parameters)
+      case 'formatDate':
+        return _formatDate(data, parameters)
+      case 'get':
+        if (parameters.length > 2) {
+          throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException)
+        }
+        if (parameters.length === 2) {
+          failover = parameters[parameters.length - 1]
+        }
+        return _get(data, parameters[0], failover)
+      case 'gt':
+        return _gt(data, parameters)
+      case 'gte':
+        return _gte(data, parameters)
+      case 'isEmpty':
+        return _isEmpty(data, parameters)
+      case 'isNotEmpty':
+        return _isNotEmpty(data, parameters)
+      case 'join':
+        return _join(data, parameters[0])
+      case 'lt':
+        return _lt(data, parameters)
+      case 'lte':
+        return _lte(data, parameters)
+      case 'map':
+        return _map(data, parameters)
+      case 'neq':
+        return _neq(data, parameters)
+      case 'removeHtml':
+        return _removeHtml(data, parameters)
+      case 'toLowerCase':
+        return _toLowerCase(data)
+      case 'toUpperCase':
+        return _toUpperCase(data)
+      default:
+        throw new Error(`${functionName} is not a valid function`)
+    }
+  } catch (e) {
+    throw e
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/index.js
+
+
+
+
+;// ./lib/helpers/concatStringByArray/concatStringByArray.js
+
+
+
+
+
+function concatStringByArray(arrTemplate, data) {
+  return arrTemplate.reduce((acc, item) => {
+    const { type, value = '', restriction, template, format, showMinutes } = item
+    switch (type) {
+      case('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 ('date'): {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
+          acc += (formatDate(_value, format).toString())
+        }
+        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('group'): {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          return concatStringByArray(value, data)
+        }
+        break
+      }
+      case('label'): {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          acc += (value.toString())
+        }
+        break
+      }
+      case ('templateCompiler'): {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          const templateCompiler = new TemplateCompiler({ data })
+          acc += templateCompiler.pipe(value)
+        }
+        break
+      }
+      case('value'): {
+        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
+          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
+          acc += (_value.toString())
+        }
+        break 
+      }
+    }
+    return acc
+  }, '')
+}
+/* harmony default export */ const concatStringByArray_concatStringByArray = ({
+  concatStringByArray
+});
+
+
+
+;// ./lib/helpers/concatStringByArray/index.js
+
+
+;// ./lib/helpers/convertString/convertString.js
+
+
+function convertString(string, patternMatch = /\$\{(.+?)\}/g, value, getValueByKeys) {
+  if (!string) {
+    return ''
+  }
+  let _getValueByKeys = typeof getValueByKeys === 'function' ? getValueByKeys : getValueByKeys_getValueByKeys
+  const reg = new RegExp(patternMatch, 'g')
+  return string.replace(reg, (match, key) => {
+    const result = _getValueByKeys({ keys: key.split('.'), obj: value })
+    if (result === null || result === undefined) {
+      return ''
+    }
+    return typeof result === 'object' ? JSON.stringify(result) : result
+  })
+}
+
+/* harmony default export */ const convertString_convertString = ({
+  convertString
+});
+
+
+;// ./lib/helpers/convertString/index.js
+
+
+;// ./lib/helpers/escapeRegex/escapeRegex.js
+function escapeRegex(string) {
+  return String(string).replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')
+}
+
+;// ./lib/helpers/escapeRegex/index.js
+
+
+;// ./lib/helpers/expressHelper/customHandler.js
+function customHandler({ responseHelper, handler, ignoreError = false }) {
+  return async (req, res, next) => {
+    try {
+      await handler({ req, res })
+      await next()
+    } catch (err) {
+      if (ignoreError || !responseHelper) {
+        await next()
+      } else {
+        res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
+      }
+    }
+  }
+}
+
+;// ./lib/helpers/expressHelper/findAllResult.js
+function findAllResult({ responseHelper, service }) {
+  return async (req, res, next) => {
+    try {
+      const { query } = req
+      const result = await service.findAll({ query })
+      res.locals.findAllResult = result
+      await next()
+    } catch (err) {
+      res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
+    }
+  }
+}
+
+;// ./lib/helpers/expressHelper/findOneResult.js
+function findOneResult({ responseHelper, service }) {
+  return async (req, res, next) => {
+    try {
+      const { params, query } = req
+      const { id } = params
+      const result = await service.findOne({
+        query: {
+          ...query,
+          id
+        }
+      })
+      res.locals.findOneResult = result
+      await next()
+    } catch (err) {
+      res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
+    }
+  }
+}
+
+;// ./lib/helpers/expressHelper/postResult.js
+function postResult({ responseHelper, service }) {
+  return async (req, res, next) => {
+    try {
+      const { body } = req
+      let result
+      if (Array.isArray(body)) {
+        result = await service.saveAll({ docs: body })
+      } else {
+        result = await service.saveOne({ doc: body })
+      }
+      res.locals.postResult = result
+      await next()
+    } catch (err) {
+      res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
+    }
+  }
+}
+
+;// ./lib/helpers/expressHelper/updateOneResult.js
+function updateOneResult({ responseHelper, service }) {
+  return async (req, res, next) => {
+    try {
+      const { body, params } = req
+      const { id } = params
+      if (id !== body.id) {
+        throw new Error('id in params and body must be same')
+      }
+      const { data } = await service.findOne({ query: { id } })
+      const doc = data[0]
+      doc.update(body)
+      const result = await service.saveOne({ doc })
+      res.locals.updateOneResult = result
+      await next()
+    } catch (err) {
+      res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
+    }
+  }
+}
+
+;// ./lib/helpers/expressHelper/index.js
+
+
+
+
+
+
+
+const expressHelper = {
+  customHandler: customHandler,
+  findAllResult: findAllResult,
+  findOneResult: findOneResult,
+  postResult: postResult,
+  updateOneResult: updateOneResult,
+}
+
+;// ./lib/helpers/extractEmails/extractEmails.js
+/**
+ * Extracts and normalizes unique email addresses from an array containing messy entries
+ * @param {Array} dirtyArray - Array that may contain emails in various formats (may include null/empty entries)
+ * @returns {Array} Sorted array of unique, lowercase email addresses
+ */
+function extractEmails(dirtyArray) {
+  const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g
+  const emails = new Set()
+
+  // Handle null/undefined input array
+  if (!dirtyArray) return []
+
+  dirtyArray.forEach(entry => {
+    // Skip null, undefined, empty, or whitespace-only entries
+    if (!entry || typeof entry !== 'string' || !entry.trim()) return
+
+    try {
+      const cleanEntry = entry
+        .replace(/[\u200B-\u200D\uFEFF\u202A-\u202E]/g, '') // Remove hidden chars
+        .replace(/[<>]/g, ' ')  // Convert email delimiters to spaces
+        .replace(/\s+/g, ' ')   // Collapse multiple whitespace
+        .trim()
+
+      // Extract all email matches
+      const matches = cleanEntry.match(emailRegex)
+      if (matches) {
+        matches.forEach(email => emails.add(email.toLowerCase())) // Normalize to lowercase
+      }
+    } catch (e) {
+      console.warn('Failed to process entry:', entry, e)
+    }
+  })
+
+  // Convert Set to array and sort alphabetically
+  return Array.from(emails).sort((a, b) => a.localeCompare(b))
+}
+
+;// ./lib/helpers/extractEmails/index.js
+
+
+;// ./lib/helpers/objectHelper/objectHelper.js
+const objectHelper = {
+  get(obj, path) {
+    const parts = path.split('.')
+    return parts.reduce((acc, part) => {
+      if (part.endsWith('[]')) {
+        // 处理数组遍历
+        const key = part.slice(0, -2) // 去掉 '[]' 得到属性名
+        if (Array.isArray(acc[key])) {
+          return acc[key] // 返回整个数组
+        }
+        return [] // 如果不是数组，返回空数组
+      }
+      if (part.includes('[') && part.includes(']')) {
+        // 处理数组索引
+        const arrayMatch = part.match(/(\w+)\[(\d+)\]/)
+        if (arrayMatch) {
+          const key = arrayMatch[1]
+          const index = arrayMatch[2]
+          return acc && acc[key] && acc[key][index]
+        }
+      } else if (acc && Array.isArray(acc)) {
+        // 如果当前值是数组，提取每个对象的指定属性
+        return acc.map((item) => item[part])
+      } else {
+        // 处理普通属性
+        return acc && acc[part]
+      }
+    }, obj)
+  },
+  merge,
+  set(obj, path, value) {
+    const parts = path.split('.');
+    let current = obj;
+
+    // 处理所有中间部分
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      let key, index;
+
+      // 检查是否是数组索引格式，如key[0]
+      const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+      if (arrayMatch) {
+        key = arrayMatch[1];
+        index = parseInt(arrayMatch[2], 10);
+        // 确保当前层级的数组存在
+        if (!current[key] || !Array.isArray(current[key])) {
+          current[key] = [];
+        }
+        // 扩展数组到足够大
+        while (current[key].length <= index) {
+          current[key].push(undefined);
+        }
+        // 如果当前位置未定义或为null，初始化为对象
+        if (current[key][index] == null) {
+          current[key][index] = {};
+        }
+        current = current[key][index];
+      } else {
+        // 处理普通属性
+        if (!current[part]) {
+          current[part] = {};
+        }
+        current = current[part];
+      }
+    }
+
+    // 处理最后一部分
+    const lastPart = parts[parts.length - 1];
+    const arrayMatch = lastPart.match(/^(\w+)\[(\d+)\]$/);
+    if (arrayMatch) {
+      const key = arrayMatch[1];
+      const index = parseInt(arrayMatch[2], 10);
+      // 确保数组存在
+      if (!current[key] || !Array.isArray(current[key])) {
+        current[key] = [];
+      }
+      // 扩展数组到所需索引
+      while (current[key].length <= index) {
+        current[key].push(undefined);
+      }
+      current[key][index] = value;
+    } else {
+      current[lastPart] = value;
+    }
+  }
+}
+
+function merge(target, ...sources) {
+  if (!sources.length) return target
+
+  const source = sources.shift() // 取出第一个源对象
+
+  if (_isObject(target) && _isObject(source)) {
+    for (const key in source) {
+      if (_isObject(source[key])) {
+        if (!target[key]) {
+          // 如果目标对象没有该属性，创建一个空对象
+          target[key] = {}
+        }
+        // 递归合并
+        merge(target[key], source[key])
+      } else {
+        // 直接覆盖
+        target[key] = source[key]
+      }
+    }
+  }
+
+  // 继续合并剩余的源对象
+  return merge(target, ...sources)
+}
+
+function _isObject(obj) {
+  return obj && typeof obj === 'object' && !Array.isArray(obj)
+}
+
+
+
+;// ./lib/helpers/objectHelper/index.js
+
+
+
+
+;// ./lib/helpers/pReduce/pReduce.js
+async function pReduce(iterable, reducer, initialValue) {
+	return new Promise((resolve, reject) => {
+		const iterator = iterable[Symbol.iterator]()
+		let index = 0
+
+		const next = async total => {
+			const element = iterator.next()
+
+			if (element.done) {
+				resolve(total)
+				return
+			}
+
+			try {
+				const [resolvedTotal, resolvedValue] = await Promise.all([total, element.value])
+				next(reducer(resolvedTotal, resolvedValue, index++))
+			} catch (error) {
+				reject(error)
+			}
+		}
+
+		next(initialValue)
+	})
+}
+
+
+
+;// ./lib/models/repo/repo.js
+
+
+class Repo {
+  constructor(options) {
+    options = options || {}
+    this.model = options.model
+    this._sharedOptions = options._sharedOptions // { session: this.dbTransaction }
+    this._queryOptions = options._queryOptions
+    this._saveOptions = options._saveOptions
+    this._Class = options._constructor && options._constructor._Class
+      ? options._constructor._Class
+      : null
+  }
+  static init(options = {}) {
+    return init(this, options)
+  }
+  static get _classname() {
+    return 'Repo'
+  }
+  static get _superclass() {
+    return 'Repo'
+  }
+
+  get _classname() {
+    return 'Repo'
+  }
+
+  get _superclass() {
+    return 'Repo'
+  }
+
+  get isValid() {
+    return this.model
+      && (typeof this.model.deleteOne === 'function')
+      && (typeof this.model.findAll === 'function')
+      && (typeof this.model.saveOne === 'function')
+  }
+
+  get queryOptions() {
+    return {
+      ...this._sharedOptions,
+      ...this._queryOptions,
+    }
+  }
+
+  get saveOptions() {
+    return {
+      ...this._sharedOptions,
+      ...this._saveOptions,
+    }
+  }
+
+  init(options) {
+    if (this._Class && typeof this._Class.init === 'function') {
+      return this._Class.init(options)
+    }
+    return options
+  }
+
+  async deleteOne({ id }) {
+    try {
+      const result = await this.model.deleteOne({ _id: id })
+      return {
+        ...result, // { message: 'ok', total }
+        isNew: false,
+        data: []
+      }
+    } catch (err) {
+      throw err
+    }
+  }
+
+  // systemLog is optional
+  findAll({ query, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_READ',
+      message: `fn ${this._classname}.prototype.findAll`,
+      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
+    })
+    return new Promise((resolve, reject) => {
+      this.model.findAll(query, this.queryOptions, (err, data, total) => {
+        if (err) {
+          log({ level: 'warn', output: err.toString() })
+          reject(err)
+        } else {
+          const result = {
+            isNew: false,
+            data,
+            total: total || data.length
+          }
+          log({ level: 'info', output: { ...result } })
+          resolve(result)
+        }
+      })
+    })
+  }
+
+  findOne({ query, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_READ',
+      message: `fn ${this._classname}.prototype.findOne`,
+      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
+    })
+    return new Promise((resolve, reject) => {
+      this.model.findAll(query, this.queryOptions, (err, data) => {
+        if (err) {
+          reject(err)
+        } else if (data.length === 1) {
+          const result = {
+            isNew: false,
+            data,
+            total: 1
+          }
+          log({ level: 'info', output: { ...result } })
+          resolve(result)
+        } else if (data.length === 0) {
+          reject(new Error('record not found'))
+        } else {
+          reject(new Error('more than one is found'))
+        }
+      })
+    })
+      .catch((err) => {
+        log({ level: 'warn', output: err.toString() })
+        throw err
+      })
+  }
+
+  saveAll({ config = {}, docs, systemLog }) {
+    let isNew
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_WRITE',
+      message: `fn ${this._classname}.prototype.saveAll`,
+      input: [{ config, docs: [...docs], systemLog: { ...systemLog } }]
+    })
+    const promise = typeof this.model.saveAll === 'function'
+      ? this.model.saveAll({ config, docs })
+      : Promise.all(docs.map(async (doc) => {
+        if (doc) {
+          const result = await this.saveOne({ config, doc })
+          isNew = result.isNew
+          const _data = result._data || result.data
+          return _data[0]
+        }
+        return null
+      }))
+    return promise.then((savedData) => {
+      if (savedData.length !== 1) isNew = null
+      const result = {
+        data: savedData,
+        isNew,
+        total: savedData.length
+      }
+      log({ level: 'info', output: { ...result } })
+      return result
+    }).catch((err) => {
+      log({ level: 'warn', output: err.toString() })
+      throw err
+    })
+  }
+
+  saveOne({ config = {}, doc, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_WRITE',
+      message: `fn ${this._classname}.prototype.saveOne`,
+      input: [{ config, doc: { ...doc }, systemLog: { ...systemLog } }]
+    })
+    const saveOptions = {
+      ...this.saveOptions,
+      ...config,
+    }
+    return new Promise((resolve, reject) => {
+      this.model.saveOne(doc, saveOptions, (err, result) => {
+        if (err) {
+          log({ level: 'warn', output: err.toString() })
+          reject(err)
+        } else {
+          log({ level: 'info', output: { ...result } })
+          resolve(result)
+        }
+      })
+    })
+  }
+}
+
+function _makeLog({ systemLog, label, message: message1, input } = {}) {
+  return ({ level, messgae: massage2, output } = {}) => {
+    if (systemLog && systemLog.systemLogHelper) {
+      systemLog.systemLogHelper.log({
+        batchId: systemLog.batchId,
+        label,
+        level,
+        message: massage2 || message1,
+        data: {
+          payload: {
+            input,
+            output
+          }
+        }
+      })
+    }
+  }
+}
+
+
+
+;// ./lib/models/repo/index.js
+
+
+
+
+;// ./lib/models/apiResponse/apiResponse.js
+class ApiResponse {
+  constructor(options = {}) {
+    options = options || {}
+    this._data = options.data || options._data || []
+    this.err = options.err
+    this.isNew = options.isNew || false
+    this.message = options.message
+    this.total = options.total || 0
+    this._instanceBuilder = options._instanceBuilder
+  }
+
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
+    }
+    const instance = new this(options)
+    return instance
+  }
+  static get _classname() {
+    return 'ApiResponse'
+  }
+  static get _superclass() {
+    return 'ApiResponse'
+  }
+
+  // getters
+  get data() {
+    if (this._instanceBuilder && (typeof this._instanceBuilder === 'function')) {
+      return this._data.map(this._instanceBuilder)
+    }
+    return this._data
+  }
+}
+
+
+
+;// ./lib/models/apiResponse/makeApiResponse.js
+
+
+function makeApiResponse({ repo, result }) {
+  return ApiResponse.init({
+    ...result,
+    _instanceBuilder: (i) => {
+      return repo.init(i)
+    }
+  })
+}
+
+
+
+;// ./lib/models/service/service.js
+
+
+
+class Service {
+  constructor({ repo }) {
+    this.repo = repo
+  }
+
+  static get _classname() {
+    return 'Service'
+  }
+  static get _superclass() {
+    return 'Service'
+  }
+
+  async deleteOne({ id }) {
+    const result = await this.repo.deleteOne({ id })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
+    // return this.repo.delete({ id })
+    //   .catch(() => {
+    //     throw new Error(`Not found for query: ${id}`)
+    //   })
+  }
+
+  async findAll({ query = {}, systemLog } = {}) {
+    const result = await this.repo.findAll({ query, systemLog })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
+  }
+
+  async findOne({ query = {}, systemLog } = {}) {
+    const result = await this.repo.findOne({ query, systemLog })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
+  }
+
+  init(options) {
+    return this.repo.init(options)
+  }
+  initFromArray(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.map((a) => this.init(a))
+    }
+    return []
+  }
+  initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+
+  async saveAll({ config = {}, docs = [], systemLog } = {}) {
+    const copies = docs.map((doc) => {
+      return config.skipInit ? doc : this.init(doc)
+    })
+    const result = await this.repo.saveAll({ config, docs: copies, systemLog })
+    return makeApiResponse({
+      repo: this.repo,
+      result
+    })
+  }
+
+  // set skipInit to true if we want to use POST for query
+  async saveOne({ config = {}, doc = {}, systemLog } = {}) {
+    const copy = config.skipInit ? doc : this.init(doc)
+    if (copy) {
+      const result = await this.repo.saveOne({ config, doc: copy, systemLog })
+      return makeApiResponse({
+        repo: this.repo,
+        result
+      })
+    }
+    return {
+      isNew: null,
+      data: [],
+      err: new Error('doc is not a valid instance')
+    }
+  }
+}
+
+function makeService({ repo }) {
+  if (repo === undefined) {
+    throw new Error('repo is required.')
+  }
+  if (repo._superclass !== Repo._superclass) {
+    throw new Error('repo is not an instance of Repo.')
+  }
+  return new Service({ repo })
+}
+
+
+
+;// ./lib/models/service/index.js
+
+
+
+
+;// ./lib/helpers/generalPost/generalPost.js
+
+
+
+
+
+async function generalPost({ body = {}, GeneralModel, UniqueKeyGenerator, resourceInfo }) {
+  const { resources, data, globalShared = {}, shared = {}, relationship = {} } = body
+  const _resourceInfo = resourceInfo || body.resourceInfo
+  _attachShared(data, globalShared, shared)
+  const obj = await pReduce(resources, async (acc, resource) => {
+    const service = _makeService(resource, _resourceInfo, UniqueKeyGenerator, GeneralModel)
+    _createRelationship(data, relationship[resource], acc)
+    const _data = data[resource]
+    const result = await service.saveAll({ docs: [].concat(_data) })
+    acc[resource] = Array.isArray(_data) ? result._data : result._data[0]
+    return acc
+  }, {})
+  return obj
+}
+
+function _attachShared(data, globalShared = {}, shared = {}) {
+  Object.keys(shared).forEach((key) => {
+    const _data = data[key]
+    if (Array.isArray(_data)) {
+      data[key] = _data.map((_dataItem) => {
+        return objectHelper.merge({}, _dataItem, globalShared, shared[key] || {})
+      })
+    } else {
+      data[key] = objectHelper.merge({}, _data, globalShared, shared[key] || {})
+    }
+  })
+}
+
+function _createRelationship(data, relationship = {}, object) {
+  Object.keys(relationship).forEach((key) => {
+    const path = relationship[key]
+    const val = objectHelper.get(object, path)
+    objectHelper.set(data, key, val)
+  })
+}
+
+function _makeService(resource, resourceInfo, UniqueKeyGenerator, GeneralModel) {
+  const { collectionName, fields } = resourceInfo[resource]
+  const uniqueKeyGenerator = UniqueKeyGenerator.makeGenerator(fields)
+  const model = new GeneralModel({ collectionName, uniqueKeyGenerator })
+  return makeService({
+    repo: new Repo({ model })
+  })
+}
+
+
+
+;// ./lib/helpers/generalPost/index.js
+
+
+
+
+;// ./lib/helpers/groupArrayByKey/groupArrayByKey.js
+function groupArrayByKey(arr, key) {
+  if (!key || typeof key !== 'string') {
+    return {}
+  }
+  return arr.reduce((acc, curr) => {
+    if (!acc[curr[key]]) {
+      acc[curr[key]] = 0
+    }
+    acc[curr[key]]++
+    return acc
+  }, {})
+}
+
+;// ./lib/helpers/groupArrayByKey/index.js
+
+
+;// ./lib/helpers/init/init.js
+function init(_class, options) {
+  if (options instanceof _class) {
+    return options
+  }
+  try {
+    const instance = new _class(options)
+    return instance.isValid !== false ? instance : null
+  } catch (e) {
+    console.log(`init failed for class: ${_class._classname || 'no _classname'}`, e)
+    return null
+  }
+}
+
+;// ./lib/helpers/init/index.js
+
+
+;// ./lib/helpers/initFromArray/initFromArray.js
+
+
+function initFromArray(_class, arr) {
+  if (Array.isArray(arr)) {
+    return arr.map((a) => init(_class, a))
+  }
+  return []
+}
+
+;// ./lib/helpers/initFromArray/index.js
+
+
+;// ./lib/helpers/initOnlyValidFromArray/initOnlyValidFromArray.js
+
+
+function initOnlyValidFromArray(_class, arr) {
+  return initFromArray(_class, arr).filter((i) => i)
+}
+
+;// ./lib/helpers/initOnlyValidFromArray/index.js
+
+
+;// ./lib/helpers/mergeArraysByKey/mergeArraysByKey.js
+function mergeArraysByKey(arr1, arr2) {
+  // Handle undefined/null inputs by defaulting to empty arrays
+  const safeArr1 = Array.isArray(arr1) ? arr1 : []
+  const safeArr2 = Array.isArray(arr2) ? arr2 : []
+
+  const mergedMap = new Map()
+
+  // Helper function to merge values based on their type
+  const mergeValues = (existingValue, newValue) => {
+    if (existingValue === undefined) return newValue
+    
+    // Handle arrays by concatenating
+    if (Array.isArray(existingValue) && Array.isArray(newValue)) {
+      return [...new Set([...existingValue, ...newValue])]
+    }
+    
+    // Handle objects by merging
+    if (typeof existingValue === 'object' && typeof newValue === 'object' && 
+        !Array.isArray(existingValue) && !Array.isArray(newValue)) {
+      return { ...existingValue, ...newValue }
+    }
+    
+    // // Handle numbers by adding
+    // if (typeof existingValue === 'number' && typeof newValue === 'number') {
+    //   return existingValue
+    // }
+    
+    // // Handle strings by concatenating
+    // if (typeof existingValue === 'string' && typeof newValue === 'string') {
+    //   return existingValue
+    // }
+    
+    // Default: use the new value
+    return newValue
+  }
+
+  // Process first array
+  safeArr1.forEach(item => {
+    mergedMap.set(item.key, item.value)
+  })
+
+  // Process second array and merge values
+  safeArr2.forEach(item => {
+    const existingValue = mergedMap.get(item.key)
+    mergedMap.set(item.key, mergeValues(existingValue, item.value))
+  })
+
+  // Convert back to array format
+  return Array.from(mergedMap.entries()).map(([key, value]) => ({
+    key,
+    value
+  }))
+}
+
+;// ./lib/helpers/mergeArraysByKey/index.js
+
+
+;// ./lib/helpers/padZeros/padZeros.js
+function padZeros(num, minLength = 6) {
+  num = num.toString()
+  if (num.length < minLength) {
+    return padZeros('0' + num, minLength)
+  }
+  return num
+}
+
+
+
+;// ./lib/helpers/padZeros/index.js
+
+
+
+
+;// ./lib/helpers/pReduce/index.js
+
+
+
+
+;// ./lib/helpers/replacePlaceholders/replacePlaceholders.js
+function replacePlaceholders({ content, mapping }) {
+  let isObjectMode = false
+  
+  if (typeof content === 'object' && content !== null) {
+    content = JSON.stringify(content)
+    isObjectMode = true
+  }
+
+  // [[ eventRegistration.eventRegistrationCode | 0  ]]
+  const regex = /(\[*)\[\[\s*([\w.\-_]+)(?:\s*\|\s*([^:\]\s]+))?(?:\s*:\s*([^\]\s]+))?\s*\]\](\]*)/g;
+
+  const result = content.replace(regex, (match, leadingBrackets, path, defaultValue, type, trailingBrackets) => {
+    
+    // Split the path into parts
+    const keys = path.trim().split('.')
+    
+    // Traverse the nested object structure
+    let value = mapping
+    for (const key of keys) {
+      // Handle empty keys (in case of double dots or leading/trailing dots)
+      if (!key) continue
+      
+      value = value?.[key]
+      if (value === undefined) {
+        break
+      }
+    }
+
+    // Apply default if missing
+    if (value === undefined) value = defaultValue?.trim();
+    if (value === undefined) return isObjectMode ? undefined : match;
+    
+    value = value !== undefined 
+      ? leadingBrackets + value + trailingBrackets
+      : match
+
+    // Return replacement or original if not found
+    return value
+  })
+
+  if (isObjectMode) {
+    return JSON.parse(result)
+  }
+  return result
+}
+
+;// ./lib/helpers/replacePlaceholders/index.js
+
+
+;// ./lib/helpers/sanitizeText/sanitizeText.js
+/**
+ * Sanitizes input by removing hidden/control characters with customizable whitespace handling.
+ * @param {string} input - The string to sanitize.
+ * @param {Object} [options] - Configuration options.
+ * @param {boolean} [options.normalizeWhitespace=true] - Collapse multiple spaces/tabs into one space.
+ * @param {boolean} [options.removeNewlines=false] - If true, replaces newlines with spaces.
+ * @param {boolean} [options.trim=true] - If true, trims leading/trailing whitespace.
+ * @returns {string} The sanitized string.
+ */
+function sanitizeText(input, options = {}) {
+  const {
+    normalizeWhitespace = true,
+    removeNewlines = false,
+    trim = true,
+    preserveBasicWhitespace = true, // new option to keep tabs, newlines if removeNewlines=false
+  } = options
+
+  if (typeof input !== 'string') {
+    return input
+  }
+
+  let result = input
+
+  // Phase 1: Remove all control characters except basic whitespace if requested
+  if (preserveBasicWhitespace && !removeNewlines) {
+    // Keep tab (\t), newline (\n), carriage return (\r)
+    result = result.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F\u200B-\u200D\uFEFF\u202A-\u202E]/g, '')
+  } else {
+    // Remove all control characters including basic whitespace
+    result = result.replace(/[\x00-\x1F\x7F-\x9F\u200B-\u200D\uFEFF\u202A-\u202E]/g, '')
+  }
+
+  // Phase 2: Handle whitespace transformations
+  if (removeNewlines) {
+    result = result.replace(/[\r\n]+/g, ' ')  // Convert newlines to spaces
+  }
+
+  if (normalizeWhitespace) {
+    result = result.replace(/[ \t]+/g, ' ')  // Collapse spaces/tabs to single space
+  }
+
+  // Phase 3: Final trimming
+  if (trim) {
+    result = result.trim()
+  }
+
+  return result
+}
+
+;// ./lib/helpers/sanitizeText/index.js
+
+
+;// ./lib/helpers/shuffleArray/shuffleArray.js
+function shuffleArray(array) {
+  const arr = [...array];
+  for (let i = arr.length - 1; i >= 0; i--) {  // Changed `i > 0` to `i >= 0`
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+
+;// ./lib/helpers/shuffleArray/index.js
+
+
+;// ./lib/helpers/stringFormatter/stringFormatter.js
+function stringFormatter(str, delimiter = '_') {
+  if (str === null || typeof str === 'undefined' || typeof str.toString === 'undefined') {
+    return null
+  }
+  return str.toString()
+    .trim()
+    .toUpperCase()
+    .replace('-', delimiter)
+    .replace(' ', delimiter)
+}
+
+
+
+;// ./lib/helpers/stringFormatter/index.js
+
+
+
+
+;// ./lib/helpers/stringHelper/stringHelper.js
+function baseXEncode(num, base = 34) {
+  const charset = getBaseCharset(base)
+  return encode(num, charset)
+}
+
+function encode(int, charset) {
+  const { byCode } = charset
+  if (int === 0) {
+    return byCode[0]
+  }
+
+  let res = ''
+  const max = charset.length
+  while (int > 0) {
+    res = byCode[int % max] + res
+    int = Math.floor(int / max)
+  }
+  return res
+}
+
+function getBaseCharset(base) {
+  let charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZ'
+  if (base === 58) {
+    charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz'
+  }
+  return indexCharset(charset)
+}
+
+function indexCharset(str) {
+  const byCode = {}
+  const byChar = {}
+  const { length } = str
+  let char
+  for (let i = 0; i < length; i++) {
+    char = str[i]
+    byCode[i] = char
+    byChar[char] = i;
+  }
+  return { byCode, byChar, length }
+}
+
+function isSame(str1, str2) {
+  if (typeof str1 !== 'string' || typeof str2 !== 'string') {
+    return false
+  }
+  return str1.trim().toUpperCase() === str2.trim().toUpperCase()
+}
+
+function randomString({ len = 16, pattern = 'a1' } = {}) {
+  const A = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+  const a = 'abcdefghijklmnopqrstuvwxyz'
+  const num = '1234567890'
+  const mark = '~!@#$%^&*_+-='
+  let str = ''
+  if (pattern.includes('A')) {
+    str += A
+  }
+  if (pattern.includes('a')) {
+    str += a
+  }
+  if (pattern.includes('1')) {
+    str += num
+  }
+  if (pattern.includes('#')) {
+    str += mark
+  }
+  const chars = [...str]
+  return [...Array(len)].map(i => {
+    return chars[(Math.random() * chars.length) | 0]
+  }).join``
+}
+
+function reverse(str) {
+  const _str = (typeof str !== 'string') ? str.toString() : str
+  const splitString = _str.split('')
+  const reverseArray = splitString.reverse()
+  return reverseArray.join('')
+}
+
+function setCode(base = 34) {
+  const now = (new Date()).valueOf()
+  const random = randomString({
+    len: 8,
+    pattern: '1'
+  })
+  const str = reverse(`${now}${random}`)
+  // const str = `${now}${random}`
+  return baseXEncode(str, base)
+}
+
+function toCamelCase(str) {
+  if (!str) return ''
+  return str
+    .trim()
+    .split(/\s+/)
+    .map((word, index) => {
+      if (!word) return ''
+      if (index === 0) {
+        return word.toLowerCase()
+      }
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+    })
+    .join('')
+}
+
+function toLowerCase(str) {
+  if (!str) return ''
+  return str
+    .trim()
+    .toLowerCase()
+}
+
+const stringHelper = {
+  isSame,
+  setCode,
+  toCamelCase,
+  toLowerCase,
+}
+
+
+
+;// ./lib/helpers/stringHelper/index.js
+
+
+
+
+;// ./lib/helpers/trackingPlugin/trackingPlugin.js
+function trackingPlugin(schema, options) {
+  // Add meta fields
+  schema.add({
+    meta: {
+      active: { type: Boolean, default: true },
+      created: { type: Number },
+      creator: { type: String },
+      deleted: { type: Boolean, default: false },
+      modified: { type: Number },
+      owner: { type: String },
+    }
+  })
+
+  // Auto-update hook
+  schema.pre('save', function(next) {
+    this.meta.modified = Date.now()
+    next()
+  })
+
+  // Add core indexes
+  schema.index({
+    'meta.active': 1,
+    'meta.deleted': 1
+  }, {
+    name: 'tracking_status_index',
+    background: true,
+    partialFilterExpression: { 
+      'meta.active': true,
+      'meta.deleted': false 
+    }
+  })
+
+  // Optional: Add helper methods
+  // schema.methods.touch = function(userId) {
+  //   this.meta.updatedAt = new Date()
+  //   this.meta.updatedBy = userId
+  // }
+}
+
+;// ./lib/helpers/tenantPlugin/tenantPlugin.js
+
+
+function tenantPlugin(schema, options) {
+  // Apply tracking plugin first if not already present
+  if (!schema.path('meta')) {
+    trackingPlugin(schema, options)
+  }
+
+  // Add tenant-specific fields
+  schema.add({
+    metadata: [{ type: Object }], // Instead of Schema.Types.Mixed
+    remarks: [{ type: Object }],
+    tenantCode: { type: String, required: true }
+  })
+
+  // Add core indexes
+  schema.index({
+    'tenantCode': 1
+  }, {
+    name: 'tenant_core_index',
+    background: true
+  })
+
+  // 1. ENHANCE EXISTING TRACKING INDEXES
+  const existingIndexes = schema.indexes()
+  
+  // Check if tracking_status_index exists
+  const hasTenantStatusIndex = existingIndexes.some(idx => 
+    idx.name === 'tenant_status_index' // Check by name for reliability
+  )
+
+  if (!hasTenantStatusIndex) {
+    schema.index({
+      'tenantCode': 1, // Unique field first
+      _type: 1, // Low-cardinality field last
+    }, {
+      name: 'tenant_status_index',
+      background: true,
+      partialFilterExpression: {
+        '_type': 'Tenant',
+        'meta.active': true,
+        'meta.deleted': false 
+      }
+    })
+  }
+}
+
+;// ./lib/helpers/tenantPlugin/index.js
+
+
+;// ./lib/helpers/trackingPlugin/index.js
+
+
+;// ./lib/helpers/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./lib/models/apiResponse/index.js
+
+
+
+
+
+;// ./lib/models/awsStsS3Client/awsStsS3Client.js
+class AwsStsS3Client {
+  constructor(options) {
+    options = options || {}
+
+    this.expiration = options.expiration || null
+    this.s3Client = options.s3Client || null
+    this.getIdToken = options.getIdToken
+    this.region = options.region || 'ap-east-1'
+    this.roleArn = options.roleArn
+    this.roleSessionName = options.roleSessionName || 'web-identity-session'
+    this.durationSession = options.durationSession || 3600
+    this.awsClientSts = options.awsClientSts
+    this.awsClientS3 = options.awsClientS3
+  }
+
+  static dummyData() {
+    return {
+      getIdToken: () => 'mock-web-identity-token',
+      roleArn: 'arn:aws:iam::846252828949:role/oidcS3Jccpa',
+      awsClientSts: {
+        STSClient: class {},
+        AssumeRoleWithWebIdentityCommand: class {}
+      },
+      awsClientS3: {
+        S3Client: class {},
+        PutObjectCommand: class {},
+        GetObjectCommand: class {},
+        DeleteObjectCommand: class {}
+      }
+    }
+  }
+
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
+    }
+    try {
+      const instance = new this(options)
+      if (!instance.isValid) {
+        return null
+      }
+      return instance
+    } catch (error) {
+      return null
+    }
+  }
+
+  get isExpired() {
+    if (!this.expiration) return true;
+    const now = new Date();
+    const bufferMs = 1 * 60 * 1000; // 一分钟缓冲
+    return now >= new Date(this.expiration.getTime() - bufferMs);
+  }
+
+  get isValid() {
+    if (!this.getIdToken) {
+      throw new Error('Missing required configuration: getIdToken function')
+    }
+    if (!this.roleArn) {
+      throw new Error('Missing required configuration: roleArn')
+    }
+    if (!this.awsClientSts) {
+      throw new Error('Missing required AWS awsClientSts client configuration')
+    }
+    if (!this.awsClientSts.STSClient) {
+      throw new Error('Missing STSClient in AWS awsClientSts client configuration')
+    }
+    if (!this.awsClientSts.AssumeRoleWithWebIdentityCommand) {
+      throw new Error('Missing AssumeRoleWithWebIdentityCommand in AWS awsClientSts client configuration')
+    }
+    if (!this.awsClientS3) {
+      throw new Error('Missing required AWS awsClientS3 client configuration')
+    }
+
+    const requiredS3Components = [
+      'S3Client',
+      'PutObjectCommand',
+      'GetObjectCommand',
+      'DeleteObjectCommand'
+    ]
+
+    for (const component of requiredS3Components) {
+      if (!this.awsClientS3[component]) {
+        throw new Error(`Missing ${component} in AWS awsClientS3 client configuration`)
+      }
+    }
+    
+    return true
+  }
+
+  async refreshCredentials() {
+    try {
+      const webIdentityToken = await this.getIdToken()
+      if (!webIdentityToken) {
+        throw new Error('getIdToken function returned empty or invalid token')
+      }
+    
+      const stsClient = new this.awsClientSts.STSClient({ region: this.region })
+      
+      const stsResponse = await stsClient.send(
+        new this.awsClientSts.AssumeRoleWithWebIdentityCommand({
+          RoleArn: this.roleArn,
+          RoleSessionName: this.roleSessionName,
+          WebIdentityToken: await this.getIdToken(),
+          DurationSeconds: this.durationSession,
+        })
+      )
+
+      const credentials = stsResponse.Credentials
+      if (!credentials) {
+        throw new Error('No credentials returned from awsClientSts')
+      }
+
+      this.expiration = credentials.Expiration
+
+      this.s3Client = new this.awsClientS3.S3Client({
+        region: this.region,
+        credentials: {
+          accessKeyId: credentials.AccessKeyId,
+          secretAccessKey: credentials.SecretAccessKey,
+          sessionToken: credentials.SessionToken,
+        }
+      })
+
+      return this
+    } catch (error) {
+      throw new Error(`Failed to refresh credentials: ${error.message}`)
+    }
+  }
+
+  async getS3Client() {
+    if (this.isExpired || !this.s3Client) {
+      await this.refreshCredentials()
+    }
+    return this.s3Client
+  }
+
+  async putObject(params) {
+    try {
+      const client = await this.getS3Client()
+      const command = new this.awsClientS3.PutObjectCommand(params)
+      await client.send(command)
+      const fileArr = params.Key.split('/')
+      return {
+        url: `https://s3.${this.region}.amazonaws.com/${params.Bucket}/${params.Key}`,
+        filename: fileArr.pop(),
+        folder: params.Bucket,
+        subFolders: fileArr
+      }
+    } catch (error) {
+      throw new Error(`Failed to put object: ${error.message}`)
+    }
+  }
+
+  async getObject(params) {
+    try {
+      const client = await this.getS3Client()
+      const command = new this.awsClientS3.GetObjectCommand(params)
+      const response = await client.send(command)
+      return {
+        body: response.Body,
+        contentType: response.ContentType,
+        lastModified: response.LastModified,
+        contentLength: response.ContentLength,
+      }
+    } catch (error) {
+      throw new Error(`Failed to get object: ${error.message}`)
+    }
+  }
+
+  async deleteObject(params) {
+    try {
+      const client = await this.getS3Client()
+      const command = new this.awsClientS3.DeleteObjectCommand(params)
+      await client.send(command)
+      return true
+    } catch (error) {
+      throw new Error(`Failed to delete object: ${error.message}`)
+    }
+  }
+}
+
+
+
+;// ./lib/models/awsStsS3Client/index.js
+
+
+
+
+;// ./lib/models/keyValueObject/keyValueObject.js
+class KeyValueObject {
+  constructor(options = {}) {
+    options = options || {}
+    this.key = options.key || null
+    this.value = (typeof options.value !== 'undefined') ? options.value : ''
+  }
+
+  // Class methods
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
+    }
+    const instance = new this(options)
+    return instance.isValid ? instance : null
+  }
+  static initFromArray(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.map((a) => this.init(a))
+    }
+    return []
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+  static get _classname() {
+    return 'KeyValueObject'
+  }
+  static get _superclass() {
+    return 'KeyValueObject'
+  }
+
+  static addItem(arr, key, value) {
+    arr.push(this.init({ key, value }))
+  }
+  static addRecord(arr = [], key, value) {
+    if (!this.hasKeyValue(arr, key, value)) {
+      arr.push(this.init({ key, value }))
+    }
+    return arr
+  }
+  static appendRecord(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
+      }
+      return item
+    })
+  }
+  static appendValueArray(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
+      }
+      return item
+    })
+  }
+  static foundByKey(arr = [], key) {
+    const found = arr.find((m) => {
+      return this.sameKey(m, key)
+    })
+    return found || null
+  }
+  static foundValueByKey(arr = [], key) {
+    const found = this.foundByKey(arr, key)
+    return found ? found.value : null
+  }
+  static fromObject(options = {}) {
+    return Object.keys(options).reduce((acc, key) => {
+      acc.push(this.init({ key, value: options[key] }))
+      return acc
+    }, [])
+  }
+  static getValueByKey(arr = [], key) {
+    return this.foundValueByKey(arr, key)
+  }
+  static getValueByKeyFromArray(arr = [], key) {
+    if (arr.length === 0) {
+      return null
+    }
+    const firstArr = arr.shift()
+    const found = firstArr.find((i) => {
+      return this.sameKey(i, key)
+    })
+    if (found && found.value) {
+      return found.value
+    }
+    return this.getValueByKeyFromArray(arr, key)
+  }
+  static getValuesByKey(arr = [], key) {
+    return arr.reduce((acc, item) => {
+      if (this.sameKey(item, key)) {
+        acc.push(item.value)
+      }
+      return acc
+    }, [])
+  }
+  static hasKeyValue(arr = [], key, value) {
+    if (typeof value === 'undefined') {
+      return arr.filter((item) => this.sameKey(item, key)).length > 0
+    }
+    return arr.filter((item) => (this.sameKey(item, key) && _isSame(item.value, value))).length > 0
+  }
+  static insertOrUpdateRecord(arr = [], key, value) {
+    let copy = [...arr]
+    if (!this.hasKeyValue(arr, key)) {
+      copy.push(this.init({ key, value }))
+    } else {
+      copy = this.updateRecord(arr, key, value)
+    }
+    return copy
+  }
+  static keys(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc.push(item.key)
+        return acc
+      }, [])
+    }
+    return []
+  }
+  static merge(toArr, fromArr) {
+    (fromArr || []).map((from) => {
+      const found = toArr.find((to) => {
+        return to.key === from.key
+      })
+      if (found) {
+        found.value = _mergeValues(from.value, found.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) {
+    if (item) {
+      return _isSame(item.key, key)
+    }
+    return false
+  }
+  static toObject(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc[item.key] = item.value
+        return acc
+      }, {})
+    }
+    return {}
+  }
+  static toString(arr = [], delimiter = '; ') {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc.push(`${item.key}: ${item.value}`)
+        return acc
+      }, []).join(delimiter)
+    }
+    return ''
+  }
+  static updateRecord(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        return {
+          ...item,
+          value
+        }
+      }
+      return item
+    })
+  }
+  static updateOrInsertRecord(arr = [], key, value) {
+    return this.insertOrUpdateRecord(arr, key, value)
+  }
+  static updateRecordsFromArray(arr = [], updateArr = []) {
+    if (Array.isArray(arr) && Array.isArray(updateArr)) {
+      const obj1 = this.toObject(arr)
+      const obj2 = this.toObject(updateArr)
+      return this.fromObject({
+        ...obj1,
+        ...obj2
+      })
+    }
+    return []
+  }
+  static values(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.reduce((acc, item) => {
+        acc.push(item.value)
+        return acc
+      }, [])
+    }
+    return []
+  }
+
+  // getters
+  get isValid() {
+    return !!this.key
+  }
+
+  get toObject() {
+    const obj = {}
+    if (this.isValid) {
+      obj[this.key] = this.value
+    }
+    return obj
+  }
+}
+
+function _mergeValues(existingValue, newValue) {
+  if (existingValue === undefined) return newValue
+  
+  // Handle arrays by concatenating
+  if (Array.isArray(existingValue) && Array.isArray(newValue)) {
+    return [...new Set([...existingValue, ...newValue])]
+  }
+  
+  // Handle objects by merging
+  if (typeof existingValue === 'object' && typeof newValue === 'object' && 
+      !Array.isArray(existingValue) && !Array.isArray(newValue)) {
+    return { ...existingValue, ...newValue }
+  }
+  
+  // // Handle numbers by adding
+  // if (typeof existingValue === 'number' && typeof newValue === 'number') {
+  //   return existingValue
+  // }
+  
+  // // Handle strings by concatenating
+  // if (typeof existingValue === 'string' && typeof newValue === 'string') {
+  //   return existingValue
+  // }
+  
+  // Default: use the new value
+  return newValue
+}
+
+function _isSame(key1, key2) {
+  return key1 === key2
+}
+
+
+
+;// ./lib/models/keyValueObject/index.js
+
+
+
+
+;// ./lib/models/metadata/metadata.js
+
+
+
+const DELIMITER = '_'
+
+class Metadata extends KeyValueObject {
+  static init(options = {}) {
+    if (options instanceof this) {
+      return options
+    }
+    const instance = new this({
+      ...options,
+      key: stringFormatter(options.key, DELIMITER),
+    })
+    return instance.isValid ? instance : null
+  }
+  static get _classname() {
+    return 'Metadata'
+  }
+
+  static merge(toArr, fromArr) {
+    (fromArr || []).map((from) => {
+      const found = toArr.find((to) => {
+        return metadata_isSame(to.key, from.key)
+      })
+      if (found) {
+        found.value = metadata_mergeValues(from.value, found.value)
+      } else {
+        toArr.push(from)
+      }
+    })
+    return toArr
+  }
+  static sameKey(item, key) {
+    return metadata_isSame(item.key, key)
+  }
+}
+
+function metadata_isSame(key1, key2) {
+  return stringFormatter(key1, DELIMITER) === stringFormatter(key2, DELIMITER)
+}
+
+function metadata_mergeValues(existingValue, newValue) {
+  if (existingValue === undefined) return newValue
+  
+  // Handle arrays by concatenating
+  if (Array.isArray(existingValue) && Array.isArray(newValue)) {
+    return [...new Set([...existingValue, ...newValue])]
+  }
+  
+  // Handle objects by merging
+  if (typeof existingValue === 'object' && typeof newValue === 'object' && 
+      !Array.isArray(existingValue) && !Array.isArray(newValue)) {
+    return { ...existingValue, ...newValue }
+  }
+  
+  // // Handle numbers by adding
+  // if (typeof existingValue === 'number' && typeof newValue === 'number') {
+  //   return existingValue
+  // }
+  
+  // // Handle strings by concatenating
+  // if (typeof existingValue === 'string' && typeof newValue === 'string') {
+  //   return existingValue
+  // }
+  
+  // Default: use the new value
+  return newValue
+}
+
+
+
+;// ./lib/models/metadata/index.js
+
+
+
+
+;// ./lib/models/trackedEntity/trackedEntity.js
+
+
+class TrackedEntity {
+  constructor(options = {}) {
+    options = options || {}
+    const timestamp = Date.now()
+    this.meta = {
+      active: options.meta?.active ?? options.active ?? true,
+      created: options.meta?.created ?? (options.created 
+      ? new Date(options.created).getTime() 
+      : timestamp),
+      creator: options.meta?.creator ?? options.creator ?? '',
+      deleted: options.meta?.deleted ?? options.deleted ?? false,
+      modified: options.meta?.modified ?? (options.modified 
+      ? new Date(options.modified).getTime() 
+      : timestamp),
+      owner: options.meta?.owner ?? options.owner ?? '',
+    }
+
+    // if (trackFlat) {
+    //   Object.assign(this, _tracking)
+    // } else {
+    //   this.meta = { ..._tracking, ...options.meta }
+    // }
+  }
+
+  // Class methods
+  static get _classname() {
+    return 'TrackedEntity'
+  }
+  static get _superclass() {
+    return 'TrackedEntity'
+  }
+
+  static init(options = {}) {
+    return init(this, options)
+  }
+  static initFromArray(arr = []) {
+    return initFromArray(this, arr)
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return initOnlyValidFromArray(this, arr)
+  }
+  // static nest(entity) {
+  //   const { active, created, creator, deleted, modified, owner, ...rest } = entity
+  //   return { ...rest, meta: { active, created, creator, deleted, modified, owner } }
+  // }
+
+  // getters
+  get isValid() {
+    return !!this
+  }
+  get active() {
+    return this.meta?.active ?? this.active
+  }
+  get created() {
+    return this.meta?.created ?? this.created
+  }
+  get creator() {
+    return this.meta?.creator ?? this.creator
+  }
+  get deleted() {
+    return this.meta?.deleted ?? this.deleted
+  }
+  get modified() {
+    return this.meta?.modified ?? this.modified
+  }
+  get owner() {
+    return this.meta?.owner ?? this.owner
+  }
+  changeCreatorOwner({ source, target }) {
+    return changeCreatorOwner(this, { source, target }).setModified()
+  }
+  delete() {
+    return this.setDeleted()
+  }
+  setActive() {
+    if (this.meta) {
+      this.meta.active = true
+    } else {
+      this.active = true
+    }
+    return this
+  }
+  setDeleted() {
+    if (this.meta) {
+      this.meta.deleted = true
+    } else {
+      this.deleted = true
+    }
+    return this
+  }
+  setModified() {
+    const timestamp = Date.now()
+    if (this.meta) {
+      this.meta.modified = timestamp
+    } else {
+      this.modified = timestamp
+    }
+    return this
+  }
+  setOwner(owner) {
+    if (!owner) {
+      return this
+    }
+    if (this.meta) {
+      this.meta.owner = owner
+    } else {
+      this.owner = owner
+    }
+    return this
+  }
+  unsetActive() {
+    if (this.meta) {
+      this.meta.active = false
+    } else {
+      this.active = false
+    }
+    return this
+  }
+  unsetDeleted() {
+    if (this.meta) {
+      this.meta.deleted = false
+    } else {
+      this.deleted = false
+    }
+    return this
+  }
+
+  update(update) {
+    if (update.meta) {
+      this.meta = { ...this.meta, ...update.meta }
+    }
+    return this.setModified()
+  }
+}
+
+;// ./lib/models/trackedEntity/index.js
+
+ // Explicit named export (optional)
+
+;// ./lib/models/pushEnvelope/pushEnvelope.js
+
+
+
+
+
+class PushEnvelope extends TrackedEntity {
+  constructor(options) {
+    options = options || {}
+    super(options)
+
+    this.id = options.id
+    this.body = options.body
+    this.data = options.data
+    this.dirty = options.dirty
+    this.metadata = Metadata.initOnlyValidFromArray(options.metadata)
+    this.remarks = KeyValueObject.initOnlyValidFromArray(options.remarks)
+    this.threadID = options.threadID
+    this.title = options.title
+  }
+  static get _classname() {
+    return 'PushEnvelope'
+  }
+  static get _superclass() {
+    return 'PushEnvelope'
+  }
+  static init(options = {}) {
+    return init(this, options)
+  }
+
+  get _classname() {
+    return 'PushEnvelope'
+  }
+
+  get _superclass() {
+    return 'PushEnvelope'
+  }
+
+  get isValid() {
+    return super.isValid && this.data
+  }
+
+}
+
+;// ./lib/models/pushEnvelope/index.js
+
+
+;// ./lib/models/qMeta/qMeta.js
+
+
+const updateAllowedProps = [
+  'attributes',
+  'ref'
+]
+
+class QMeta {
+  constructor(options = {}) {
+    options = options || {}
+    this.attributes = KeyValueObject.initOnlyValidFromArray(options.attributes)
+    this.ref = options.ref || {}
+  }
+
+  static get _classname() {
+    return 'QMeta'
+  }
+  static get _superclass() {
+    return 'QMeta'
+  }
+
+  // Class methods
+  static init(options = {}) {
+    if (options instanceof QMeta) {
+      return options
+    }
+    return new QMeta(options)
+  }
+
+  // instance methods
+  addAttribute(obj) {
+    const kvObject = KeyValueObject.init(obj)
+    if (!kvObject) {
+      throw new Error('invalid meta attribute')
+    }
+    this.attributes.push(kvObject)
+    return this
+  }
+
+  update(obj) {
+    Object.keys(obj).forEach((key) => {
+      if (updateAllowedProps.includes(key)) {
+        if (key === 'attributes') {
+          this[key] = KeyValueObject.initOnlyValidFromArray(obj[key])
+        } else {
+          this[key] = obj[key]
+        }
+      }
+    })
+    return this
+  }
+}
+
+
+
+;// ./lib/models/qMeta/index.js
+
+
+
+
+;// ./lib/models/tenantAwareEntity/tenantAwareEntity.js
+
+
+
+
+class TenantAwareEntity extends TrackedEntity {
+  constructor(options = {}) {
+    options = options || {}
+
+    /**
+     * instead of throw error, we choose to implement the isValid checking
+     */
+    // if (!options.tenantCode) {
+    //   throw new Error('tenantCode required')
+    // }
+
+    super(options)
+
+    this._tenant = options._tenant
+
+    this.metadata = Metadata.initOnlyValidFromArray(options.metadata)
+    this.remarks = KeyValueObject.initOnlyValidFromArray(options.remarks)
+    this.tenantCode = options.tenantCode // Required for multi-tenancy
+  }
+
+  // Class methods
+  static get _classname() {
+    return 'TenantAwareEntity'
+  }
+  static get _superclass() {
+    return 'TenantAwareEntity'
+  }
+
+  // getters
+  get isValid() {
+    return super.isValid && !!this.tenantCode // Required for multi-tenancy
+  }
+
+  // instance methods
+  getMetadata() {
+    return this.metadata
+  }
+  getMetadataByKey(key) {
+    return Metadata.foundByKey(this.metadata, key)
+  }
+  getMetadataValueByKey(key) {
+    const found = this.getMetadataByKey(key)
+    return found ? found.value : null
+  }
+  getRemarks() {
+    return this.remarks
+  }
+  getRemarkByKey(key) {
+    return KeyValueObject.foundByKey(this.remarks, key)
+  }
+  getRemarksValueByKey(key) {
+    const found = this.getRemarkByKey(key)
+    return found ? found.value : null
+  }
+  getTenantCode() {
+    return this.tenantCode
+  }
+
+  update(update) {
+    if (update.metadata && Array.isArray(update.metadata)) {
+      this.metadata = Metadata.initOnlyValidFromArray(update.metadata)
+    }
+    if (update.remarks && Array.isArray(update.remarks)) {
+      this.remarks = KeyValueObject.initOnlyValidFromArray(update.remarks)
+    }
+    return super.update(update)
+  }
+}
+
+;// ./lib/models/tenantAwareEntity/index.js
+
+
+
+;// ./lib/models/uniqueKeyGenerator/uniqueKeyGenerator.js
+
+
+class UniqueKeyGenerator {
+  static get _classname() {
+    return 'UniqueKeyGenerator'
+  }
+  static get _superclass() {
+    return 'UniqueKeyGenerator'
+  }
+  static makeFormatter({ fieldName, format, options }) {
+    switch (format) {
+      case 'set_code':
+        return _makeSetCode(fieldName, options)
+      default:
+        return _makeSetCode(fieldName, options)
+    }
+  }
+  static makeGenerator(arr) {
+    const fns = arr.map((item) => this.makeFormatter(item))
+    return async (obj) => {
+      const output = await pReduce(fns, async (acc, fn) => {
+        const _obj = await fn(obj)
+        return Object.assign(acc, _obj)
+      }, obj)
+      return output
+    }
+  }
+}
+
+function _makeSetCode(fieldName, options) {
+  return async (obj = {}) => {
+    if (obj[fieldName]) {
+      return {}
+    }
+    return {
+      [fieldName]: stringHelper.setCode()
+    }
+  }
+}
+
+
+
+;// ./lib/models/uniqueKeyGenerator/index.js
+
+
+
+
+;// ./lib/models/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./lib/index.js
+
+
+
+;// ./index.js
+
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});