@questwork/q-utilities 0.1.14 → 0.1.16

package/dist/q-utilities.min.js

@@ -49,6 +49,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,12 @@ __webpack_require__.d(__webpack_exports__, {
   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,25 +75,29 @@ __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),
+  tenantPlugin: () => (/* reexport */ tenantPlugin),
   trackingPlugin: () => (/* reexport */ trackingPlugin)
 });
 
 ;// ./lib/helpers/authorize/authorize.js
-function authorize({ allowOwner, query = {}, required, user }) {
+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.')
+    // throw new Error('You do not have any permission.')
   }
-  const scopes = user.permission.getScopes(required || {})
+  const scopes = user.permission.getScopes(required || {}) || []
   if (!scopes || scopes.length === 0) {
-    throw new Error('You are not allowed in this scope.')
+    // throw new Error('You are not allowed in this scope.')
   }
   if (!scopes.includes('*')) {
     query.tenantCode = user.tenantCode
@@ -96,8 +105,21 @@ function authorize({ allowOwner, query = {}, required, user }) {
   if (!scopes.includes('TENANT')) {
     query.eventShortCode = user.eventShortCode
   }
-  if (!scopes.includes('EVENT')) {
-    query.eventRegistrationCode = user.eventRegistrationCode
+  // 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
@@ -113,6 +135,29 @@ function authorize({ allowOwner, query = {}, required, user }) {
 ;// ./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) {
@@ -121,10 +166,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)
@@ -136,14 +181,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)
   }
@@ -162,6 +203,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']
     }
@@ -238,6 +282,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 = ({
@@ -1441,7 +1499,7 @@ function convertString(string, patternMatch = /\$\{(.+?)\}/g, value, getValueByK
   if (!string) {
     return ''
   }
-  let _getValueByKeys = typeof getValueByKeys !== 'function' ? getValueByKeys : getValueByKeys_getValueByKeys
+  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 })
@@ -1460,6 +1518,161 @@ function convertString(string, patternMatch = /\$\{(.+?)\}/g, value, getValueByK
 ;// ./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) {
+        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) {
@@ -1743,19 +1956,19 @@ class Repo {
       })
   }
 
-  saveAll({ docs, systemLog }) {
+  saveAll({ config = {}, docs, systemLog }) {
     let isNew
     const log = _makeLog({
       systemLog,
       label: 'REPO_WRITE',
       message: `fn ${this._classname}.prototype.saveAll`,
-      input: [{ docs: [...docs], systemLog: { ...systemLog } }]
+      input: [{ config, docs: [...docs], systemLog: { ...systemLog } }]
     })
     const promise = typeof this.model.saveAll === 'function'
-      ? this.model.saveAll({ docs })
+      ? this.model.saveAll({ config, docs })
       : Promise.all(docs.map(async (doc) => {
         if (doc) {
-          const result = await this.saveOne({ doc })
+          const result = await this.saveOne({ config, doc })
           isNew = result.isNew
           const _data = result._data || result.data
           return _data[0]
@@ -1777,15 +1990,19 @@ class Repo {
     })
   }
 
-  saveOne({ doc, systemLog }) {
+  saveOne({ config = {}, doc, systemLog }) {
     const log = _makeLog({
       systemLog,
       label: 'REPO_WRITE',
       message: `fn ${this._classname}.prototype.saveOne`,
-      input: [{ doc: { ...doc }, systemLog: { ...systemLog } }]
+      input: [{ config, doc: { ...doc }, systemLog: { ...systemLog } }]
     })
+    const saveOptions = {
+      ...this.saveOptions,
+      ...config,
+    }
     return new Promise((resolve, reject) => {
-      this.model.saveOne(doc, this.saveOptions, (err, result) => {
+      this.model.saveOne(doc, saveOptions, (err, result) => {
         if (err) {
           log({ level: 'warn', output: err.toString() })
           reject(err)
@@ -1927,11 +2144,11 @@ class Service {
     return this.initFromArray(arr).filter((i) => i)
   }
 
-  async saveAll({ docs = [], config = {}, systemLog } = {}) {
+  async saveAll({ config = {}, docs = [], systemLog } = {}) {
     const copies = docs.map((doc) => {
       return config.skipInit ? doc : this.init(doc)
     })
-    const result = await this.repo.saveAll({ docs: copies, systemLog })
+    const result = await this.repo.saveAll({ config, docs: copies, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
@@ -1939,10 +2156,10 @@ class Service {
   }
 
   // set skipInit to true if we want to use POST for query
-  async saveOne({ doc = {}, config = {}, systemLog } = {}) {
+  async saveOne({ config = {}, doc = {}, systemLog } = {}) {
     const copy = config.skipInit ? doc : this.init(doc)
     if (copy) {
-      const result = await this.repo.saveOne({ doc: copy, systemLog })
+      const result = await this.repo.saveOne({ config, doc: copy, systemLog })
       return makeApiResponse({
         repo: this.repo,
         result
@@ -2071,6 +2288,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()
@@ -2092,6 +2367,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') {
@@ -2217,10 +2588,18 @@ function toCamelCase(str) {
     .join('')
 }
 
+function toLowerCase(str) {
+  if (!str) return ''
+  return str
+    .trim()
+    .toLowerCase()
+}
+
 const stringHelper = {
   isSame,
   setCode,
   toCamelCase,
+  toLowerCase,
 }
 
 
@@ -2250,6 +2629,19 @@ function trackingPlugin(schema, options) {
     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()
@@ -2257,6 +2649,57 @@ function trackingPlugin(schema, options) {
   // }
 }
 
+;// ./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
 
 
@@ -2273,6 +2716,14 @@ function trackingPlugin(schema, options) {
 
 
 
+
+
+
+
+
+
+
+
 
 
 
@@ -2284,6 +2735,196 @@ function trackingPlugin(schema, options) {
 
 
 
+;// ./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 = {}) {
@@ -2411,7 +3052,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)
       }
@@ -2427,7 +3068,10 @@ class KeyValueObject {
     }, [])
   }
   static sameKey(item, key) {
-    return _isSame(item.key, key)
+    if (item) {
+      return _isSame(item.key, key)
+    }
+    return false
   }
   static toObject(arr = []) {
     if (Array.isArray(arr)) {
@@ -2496,6 +3140,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
 }
@@ -2534,7 +3206,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)
       }
@@ -2550,6 +3222,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
@@ -2625,17 +3325,19 @@ class TrackedEntity {
   constructor(options = {}) {
     options = options || {}
     const timestamp = Date.now()
-    const _tracking = {
-      active: options.active ?? true,
-      created: options.created ?? timestamp,
-      creator: options.creator ?? '',
-      deleted: options.deleted ?? false,
-      modified: options.modified ?? timestamp,
-      owner: options.owner ?? '',
+    this.meta = {
+      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 ?? '',
     }
 
-    this.meta = { ..._tracking, ...options.meta }
-
     // if (trackFlat) {
     //   Object.assign(this, _tracking)
     // } else {
@@ -2687,6 +3389,9 @@ class TrackedEntity {
   get owner() {
     return this.meta?.owner ?? this.owner
   }
+  changeCreatorOwner({ source, target }) {
+    return changeCreatorOwner(this, { source, target }).setModified()
+  }
   delete() {
     return this.setDeleted()
   }
@@ -2893,6 +3598,7 @@ function _makeSetCode(fieldName, options) {
 
 
 
+
 ;// ./lib/index.js