@questwork/q-utilities 0.1.13 → 0.1.15

package/dist/index.min.cjs

@@ -50,6 +50,7 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   ApiResponse: () => (/* reexport */ ApiResponse),
+  AwsStsS3Client: () => (/* reexport */ AwsStsS3Client),
   KeyValueObject: () => (/* reexport */ KeyValueObject),
   Metadata: () => (/* reexport */ Metadata),
   QMeta: () => (/* reexport */ QMeta),
@@ -59,8 +60,13 @@ __webpack_require__.d(__webpack_exports__, {
   TenantAwareEntity: () => (/* reexport */ TenantAwareEntity),
   TrackedEntity: () => (/* reexport */ TrackedEntity),
   UniqueKeyGenerator: () => (/* reexport */ UniqueKeyGenerator),
+  authorize: () => (/* reexport */ authorize),
+  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),
@@ -70,13 +76,75 @@ __webpack_require__.d(__webpack_exports__, {
   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),
   stringFormatter: () => (/* reexport */ stringFormatter),
-  stringHelper: () => (/* reexport */ stringHelper)
+  stringHelper: () => (/* reexport */ stringHelper),
+  trackingPlugin: () => (/* reexport */ trackingPlugin)
 });
 
+;// ./lib/helpers/authorize/authorize.js
+function authorize({ allowOwner, query = {}, required, user }) {
+  if (!user) {
+    throw new Error('Require login.')
+  }
+  if (!user.permission) {
+    throw new Error('You do not have any permission.')
+  }
+  const scopes = user.permission.getScopes(required || {})
+  if (!scopes || scopes.length === 0) {
+    throw new Error('You are not allowed in this scope.')
+  }
+  if (!scopes.includes('*')) {
+    query.tenantCode = user.tenantCode
+  }
+  if (!scopes.includes('TENANT')) {
+    query.eventShortCode = user.eventShortCode
+  }
+  if (!scopes.includes('EVENT')) {
+    query.eventRegistrationCode = user.eventRegistrationCode
+  }
+  if (allowOwner) {
+    query.__ALLOW_OWNER = true
+  }
+  // not good, just use it as example
+  if (user.hasExcludedFields) {
+    query.__EXCLUDED_FIELDS = user.getExcludedFields(required)
+  }
+  query.__LOGIN_SUBJECT_CODE = user.loginSubjectCode
+  return query
+}
+
+;// ./lib/helpers/authorize/index.js
+
+
+;// ./lib/helpers/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) {
@@ -85,10 +153,10 @@ function getValidation(rule, data, getDataByKey, KeyValueObject) {
   if (typeof getDataByKey !== 'function' || (KeyValueObject && typeof KeyValueObject !== 'function')) {
     return false
   }
-  const { key = '', value, keyValuePath = '' } = rule
+  const { key = '', value, placeholder, keyValuePath = '' } = rule
   const [valueAttribute] = Object.keys(value)
 
-  if (!key) {
+  if (!key && typeof placeholder === 'undefined') {
     switch (valueAttribute) {
       case '$and': {
         return value['$and'].reduce((acc, item) => (acc && getValidation(item, data, getDataByKey, KeyValueObject)), true)
@@ -100,14 +168,10 @@ function getValidation(rule, data, getDataByKey, KeyValueObject) {
         return false
     }
   }
-
-  let rowValue = getDataByKey(key, data)
-
-  // debugger
+  let rowValue = typeof placeholder === 'undefined' ? getDataByKey(key, data) : placeholder
 
   // if KeyValue object
   if (keyValuePath) {
-    console.log('keyValuePath', keyValuePath)
     const rowValueData = KeyValueObject.toObject(rowValue)
     rowValue = getDataByKey(keyValuePath, rowValueData)
   }
@@ -126,6 +190,9 @@ function getValidation(rule, data, getDataByKey, KeyValueObject) {
     case '$gte': {
       return rowValue >= value['$gte']
     }
+    case '$hasOverlap': {
+      return _hasOverlap(rowValue, value['$hasOverlap'])
+    }
     case '$lt': {
       return rowValue < value['$lt']
     }
@@ -202,6 +269,20 @@ function getValidation(rule, data, getDataByKey, KeyValueObject) {
     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 = ({
@@ -338,6 +419,7 @@ const _FN_NAMES = [
   'lte',
   'map',
   'neq',
+  'removeHtml',
   'toLowerCase',
   'toUpperCase',
 ]
@@ -926,6 +1008,66 @@ function _neq(data, args) {
 
 
 
+;// ./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
 
 
@@ -980,6 +1122,7 @@ function _toUpperCase(data, args) {
 
 
 
+
 
 
 ;// ./lib/models/templateCompiler/templateCompiler.js
@@ -1050,6 +1193,9 @@ class TemplateCompiler {
   static neq(data, args) {
     return _neq(data, args)
   }
+  static removeHtml(data, args) {
+    return _removeHtml(data, args)
+  }
   static toLowerCase(data, args) {
     return _toLowerCase(data, args)
   }
@@ -1059,6 +1205,9 @@ class TemplateCompiler {
   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
@@ -1238,6 +1387,8 @@ function _callFunction(data, functionName, parameters) {
         return _map(data, parameters)
       case 'neq':
         return _neq(data, parameters)
+      case 'removeHtml':
+        return _removeHtml(data, parameters)
       case 'toLowerCase':
         return _toLowerCase(data)
       case 'toUpperCase':
@@ -1354,6 +1505,161 @@ function convertString(string, patternMatch = /\$\{(.+?)\}/g, value, getValueByK
 ;// ./lib/helpers/convertString/index.js
 
 
+;// ./lib/helpers/escapeRegex/escapeRegex.js
+function escapeRegex(string) {
+  return 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) {
+        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) {
@@ -1386,42 +1692,59 @@ const objectHelper = {
   },
   merge,
   set(obj, path, value) {
-    const parts = path.split('.')
-    let current = obj
+    const parts = path.split('.');
+    let current = obj;
+
+    // 处理所有中间部分
     for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i]
-      if (part.endsWith('[]')) {
-        // 处理数组遍历
-        const key = part.slice(0, -2) // 去掉 '[]' 得到属性名
-        if (Array.isArray(current[key])) {
-          current[key].forEach((item) => set(item, parts.slice(i + 1).join('.'), value))
+      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] = [];
         }
-        return // 处理完数组后直接返回
-      }
-      if (part.includes('[') && part.includes(']')) {
-        // 处理数组索引
-        const arrayMatch = part.match(/(\w+)\[(\d+)\]/)
-        if (arrayMatch) {
-          const key = arrayMatch[1]
-          const index = arrayMatch[2]
-          if (Array.isArray(current[key]) && current[key][index]) {
-            current = current[key][index]
-          } else {
-            return // 如果数组或索引不存在，直接返回
-          }
+        // 扩展数组到足够大
+        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[part] = {};
         }
-        current = current[part]
+        current = current[part];
       }
     }
-  
-    // 设置最终属性值
-    const lastPart = parts[parts.length - 1]
-    current[lastPart] = value
+
+    // 处理最后一部分
+    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;
+    }
   }
 }
 
@@ -1490,6 +1813,8 @@ async function pReduce(iterable, reducer, initialValue) {
 
 
 ;// ./lib/models/repo/repo.js
+
+
 class Repo {
   constructor(options) {
     options = options || {}
@@ -1502,11 +1827,7 @@ class Repo {
       : null
   }
   static init(options = {}) {
-    if (options instanceof this) {
-      return options
-    }
-    const instance = new this(options)
-    return instance.isValid ? instance : null
+    return init(this, options)
   }
   static get _classname() {
     return 'Repo'
@@ -1698,6 +2019,11 @@ function _makeLog({ systemLog, label, message: message1, input } = {}) {
 
 
 
+;// ./lib/models/repo/index.js
+
+
+
+
 ;// ./lib/models/apiResponse/apiResponse.js
 class ApiResponse {
   constructor(options = {}) {
@@ -1842,6 +2168,11 @@ function makeService({ repo }) {
 
 
 
+;// ./lib/models/service/index.js
+
+
+
+
 ;// ./lib/helpers/generalPost/generalPost.js
 
 
@@ -1866,7 +2197,13 @@ async function generalPost({ body = {}, GeneralModel, UniqueKeyGenerator, resour
 function _attachShared(data, globalShared = {}, shared = {}) {
   Object.keys(shared).forEach((key) => {
     const _data = data[key]
-    data[key] = objectHelper.merge({}, _data, globalShared, shared[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] || {})
+    }
   })
 }
 
@@ -1901,7 +2238,7 @@ function init(_class, options) {
   }
   try {
     const instance = new _class(options)
-    return instance.isValid ? instance : null
+    return instance.isValid !== false ? instance : null
   } catch (e) {
     console.log(`init failed for class: ${_class._classname || 'no _classname'}`, e)
     return null
@@ -1934,6 +2271,64 @@ function initOnlyValidFromArray(_class, arr) {
 ;// ./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()
@@ -1955,6 +2350,102 @@ function padZeros(num, minLength = 6) {
 
 
 
+;// ./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,
+  } = options
+
+  if (typeof input !== 'string') {
+    return input
+  }
+
+  let result = input
+
+  // Phase 1: Remove hidden/control characters
+  result = result.replace(/[\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/stringFormatter/stringFormatter.js
 function stringFormatter(str, delimiter = '_') {
   if (str === null || typeof str === 'undefined' || typeof str.toString === 'undefined') {
@@ -2080,10 +2571,18 @@ function toCamelCase(str) {
     .join('')
 }
 
+function toLowerCase(str) {
+  if (!str) return ''
+  return str
+    .trim()
+    .toLowerCase()
+}
+
 const stringHelper = {
   isSame,
   setCode,
   toCamelCase,
+  toLowerCase,
 }
 
 
@@ -2093,6 +2592,36 @@ const stringHelper = {
 
 
 
+;// ./lib/helpers/trackingPlugin/trackingPlugin.js
+function trackingPlugin(schema, options) {
+  // Add meta fields
+  schema.add({
+    meta: {
+      active: { type: Boolean, default: true },
+      created: { type: Number },
+      creator: { type: String },
+      deleted: { type: Boolean, default: false },
+      modified: { type: Number },
+      owner: { type: String },
+    }
+  })
+
+  // Auto-update hook
+  schema.pre('save', function(next) {
+    this.meta.modified = Date.now()
+    next()
+  })
+
+  // Optional: Add helper methods
+  // schema.methods.touch = function(userId) {
+  //   this.meta.updatedAt = new Date()
+  //   this.meta.updatedBy = userId
+  // }
+}
+
+;// ./lib/helpers/trackingPlugin/index.js
+
+
 ;// ./lib/helpers/index.js
 
 
@@ -2105,6 +2634,15 @@ const stringHelper = {
 
 
 
+
+
+
+
+
+
+
+
+
 
 
 
@@ -2115,6 +2653,196 @@ const stringHelper = {
 
 
 
+;// ./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 = {}) {
@@ -2242,7 +2970,7 @@ class KeyValueObject {
         return to.key === from.key
       })
       if (found) {
-        found.value = (found.value || []).concat(from.value)
+        found.value = _mergeValues(from.value, found.value)
       } else {
         toArr.push(from)
       }
@@ -2327,6 +3055,34 @@ class KeyValueObject {
   }
 }
 
+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
 }
@@ -2365,7 +3121,7 @@ class Metadata extends KeyValueObject {
         return metadata_isSame(to.key, from.key)
       })
       if (found) {
-        found.value = (found.value || []).concat(from.value)
+        found.value = metadata_mergeValues(from.value, found.value)
       } else {
         toArr.push(from)
       }
@@ -2381,6 +3137,34 @@ 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
@@ -2449,21 +3233,12 @@ class QMeta {
 
 
 
-;// ./lib/models/repo/index.js
-
-
-
-
-;// ./lib/models/service/index.js
-
-
-
-
 ;// ./lib/models/trackedEntity/trackedEntity.js
 
 
 class TrackedEntity {
-  constructor(options = {}, { trackFlat = false } = {}) {
+  constructor(options = {}) {
+    options = options || {}
     const timestamp = Date.now()
     const _tracking = {
       active: options.active ?? true,
@@ -2474,11 +3249,13 @@ class TrackedEntity {
       owner: options.owner ?? '',
     }
 
-    if (trackFlat) {
-      Object.assign(this, _tracking)
-    } else {
-      this.meta = { ..._tracking, ...options.meta }
-    }
+    this.meta = { ..._tracking, ...options.meta }
+
+    // if (trackFlat) {
+    //   Object.assign(this, _tracking)
+    // } else {
+    //   this.meta = { ..._tracking, ...options.meta }
+    // }
   }
 
   // Class methods
@@ -2498,16 +3275,55 @@ class TrackedEntity {
   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 } }
-  }
+  // 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) {
@@ -2515,6 +3331,41 @@ class TrackedEntity {
     } 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()
   }
 }
 
@@ -2525,6 +3376,8 @@ class TrackedEntity {
 ;// ./lib/models/tenantAwareEntity/tenantAwareEntity.js
 
 
+
+
 class TenantAwareEntity extends TrackedEntity {
   constructor(options = {}) {
     options = options || {}
@@ -2539,6 +3392,9 @@ class TenantAwareEntity extends TrackedEntity {
     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
   }
 
@@ -2554,6 +3410,41 @@ class TenantAwareEntity extends TrackedEntity {
   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
@@ -2620,6 +3511,7 @@ function _makeSetCode(fieldName, options) {
 
 
 
+
 ;// ./lib/index.js