@questwork/q-utilities 0.1.14 → 0.1.15

package/dist/q-utilities.esm.js

@@ -34,6 +34,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) {
@@ -42,10 +65,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)
@@ -57,14 +80,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)
   }
@@ -83,6 +102,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']
     }
@@ -159,6 +181,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 = ({
@@ -1381,6 +1417,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) {
@@ -1992,6 +2183,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()
@@ -2013,6 +2262,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') {
@@ -2138,10 +2483,18 @@ function toCamelCase(str) {
     .join('')
 }
 
+function toLowerCase(str) {
+  if (!str) return ''
+  return str
+    .trim()
+    .toLowerCase()
+}
+
 const stringHelper = {
   isSame,
   setCode,
   toCamelCase,
+  toLowerCase,
 }
 
 
@@ -2195,6 +2548,13 @@ function trackingPlugin(schema, options) {
 
 
 
+
+
+
+
+
+
+
 
 
 
@@ -2205,6 +2565,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 = {}) {
@@ -2332,7 +2882,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)
       }
@@ -2417,6 +2967,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
 }
@@ -2455,7 +3033,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)
       }
@@ -2471,6 +3049,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
@@ -2608,6 +3214,9 @@ class TrackedEntity {
   get owner() {
     return this.meta?.owner ?? this.owner
   }
+  changeCreatorOwner({ source, target }) {
+    return changeCreatorOwner(this, { source, target }).setModified()
+  }
   delete() {
     return this.setDeleted()
   }
@@ -2814,6 +3423,7 @@ function _makeSetCode(fieldName, options) {
 
 
 
+
 ;// ./lib/index.js
 
 
@@ -2821,4 +3431,4 @@ function _makeSetCode(fieldName, options) {
 ;// ./index.js
 
 
-export { ApiResponse, KeyValueObject, Metadata, QMeta, Repo, Service, TemplateCompiler, TenantAwareEntity, TrackedEntity, UniqueKeyGenerator, authorize, concatStringByArray, convertString, formatDate, generalPost, getValidation, getValueByKeys_getValueByKeys as getValueByKeys, init, initFromArray, initOnlyValidFromArray, makeApiResponse, makeService, objectHelper, pReduce, padZeros, stringFormatter, stringHelper, trackingPlugin };
+export { ApiResponse, AwsStsS3Client, KeyValueObject, Metadata, QMeta, Repo, Service, TemplateCompiler, TenantAwareEntity, TrackedEntity, UniqueKeyGenerator, authorize, changeCreatorOwner, concatStringByArray, convertString, escapeRegex, expressHelper, extractEmails, formatDate, generalPost, getValidation, getValueByKeys_getValueByKeys as getValueByKeys, init, initFromArray, initOnlyValidFromArray, makeApiResponse, makeService, mergeArraysByKey, objectHelper, pReduce, padZeros, replacePlaceholders, sanitizeText, stringFormatter, stringHelper, trackingPlugin };