@questwork/q-utilities 0.1.3 → 0.1.5

package/dist/index.min.cjs

@@ -55,14 +55,19 @@ __webpack_require__.d(__webpack_exports__, {
   QMeta: () => (/* reexport */ QMeta),
   Repo: () => (/* reexport */ Repo),
   Service: () => (/* reexport */ Service),
+  UniqueKeyGenerator: () => (/* reexport */ UniqueKeyGenerator),
   convertString: () => (/* reexport */ convertString),
   formatDate: () => (/* reexport */ formatDate),
+  generalPost: () => (/* reexport */ generalPost),
   getValidation: () => (/* reexport */ getValidation),
   getValueByKeys: () => (/* reexport */ getValueByKeys),
   makeApiResponse: () => (/* reexport */ makeApiResponse),
   makeService: () => (/* reexport */ makeService),
+  objectHelper: () => (/* reexport */ objectHelper),
+  pReduce: () => (/* reexport */ pReduce),
   padZeros: () => (/* reexport */ padZeros),
-  stringFormatter: () => (/* reexport */ stringFormatter)
+  stringFormatter: () => (/* reexport */ stringFormatter),
+  stringHelper: () => (/* reexport */ stringHelper)
 });
 
 ;// ./lib/helpers/convertString/convertString.js
@@ -289,39 +294,138 @@ function getValueByKeys(keys, data) {
 ;// ./lib/helpers/getValueByKeys/index.js
 
 
-;// ./lib/helpers/padZeros/padZeros.js
-function padZeros(num, minLength = 6) {
-  num = num.toString()
-  if (num.length < minLength) {
-    return padZeros('0' + num, minLength)
+;// ./lib/helpers/objectHelper/objectHelper.js
+const objectHelper = {
+  get(obj, path) {
+    const parts = path.split('.')
+    return parts.reduce((acc, part) => {
+      if (part.endsWith('[]')) {
+        // 处理数组遍历
+        const key = part.slice(0, -2) // 去掉 '[]' 得到属性名
+        if (Array.isArray(acc[key])) {
+          return acc[key] // 返回整个数组
+        }
+        return [] // 如果不是数组，返回空数组
+      }
+      if (part.includes('[') && part.includes(']')) {
+        // 处理数组索引
+        const arrayMatch = part.match(/(\w+)\[(\d+)\]/)
+        if (arrayMatch) {
+          const key = arrayMatch[1]
+          const index = arrayMatch[2]
+          return acc && acc[key] && acc[key][index]
+        }
+      } else if (acc && Array.isArray(acc)) {
+        // 如果当前值是数组，提取每个对象的指定属性
+        return acc.map((item) => item[part])
+      } else {
+        // 处理普通属性
+        return acc && acc[part]
+      }
+    }, obj)
+  },
+  merge,
+  set(obj, path, value) {
+    const parts = path.split('.')
+    let current = obj
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i]
+      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))
+        }
+        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 // 如果数组或索引不存在，直接返回
+          }
+        }
+      } else {
+        // 处理普通属性
+        if (!current[part]) {
+          current[part] = {} // 如果属性不存在，创建一个空对象
+        }
+        current = current[part]
+      }
+    }
+  
+    // 设置最终属性值
+    const lastPart = parts[parts.length - 1]
+    current[lastPart] = value
   }
-  return num
 }
 
+function merge(target, ...sources) {
+  if (!sources.length) return target
 
+  const source = sources.shift() // 取出第一个源对象
 
-;// ./lib/helpers/padZeros/index.js
-
-
+  if (_isObject(target) && _isObject(source)) {
+    for (const key in source) {
+      if (_isObject(source[key])) {
+        if (!target[key]) {
+          // 如果目标对象没有该属性，创建一个空对象
+          target[key] = {}
+        }
+        // 递归合并
+        merge(target[key], source[key])
+      } else {
+        // 直接覆盖
+        target[key] = source[key]
+      }
+    }
+  }
 
+  // 继续合并剩余的源对象
+  return merge(target, ...sources)
+}
 
-;// ./lib/helpers/stringFormatter/stringFormatter.js
-function stringFormatter(str) {
-  return (str || '').toUpperCase().replace('-', '_').replace(' ', '_')
+function _isObject(obj) {
+  return obj && typeof obj === 'object' && !Array.isArray(obj)
 }
 
 
 
-;// ./lib/helpers/stringFormatter/index.js
+;// ./lib/helpers/objectHelper/index.js
 
 
 
 
-;// ./lib/helpers/index.js
+;// ./lib/helpers/pReduce/pReduce.js
+async function pReduce(iterable, reducer, initialValue) {
+	return new Promise((resolve, reject) => {
+		const iterator = iterable[Symbol.iterator]()
+		let index = 0
 
+		const next = async total => {
+			const element = iterator.next()
 
+			if (element.done) {
+				resolve(total)
+				return
+			}
 
+			try {
+				const [resolvedTotal, resolvedValue] = await Promise.all([total, element.value])
+				next(reducer(resolvedTotal, resolvedValue, index++))
+			} catch (error) {
+				reject(error)
+			}
+		}
 
+		next(initialValue)
+	})
+}
 
 
 
@@ -415,107 +519,85 @@ class KeyValueObject {
   }
 
   static addItem(arr, key, value) {
-    arr.push(
-      { key, value }
-    )
+    arr.push(this.init({ key, value }))
   }
   static addRecord(arr = [], key, value) {
-    const self = this
     if (!this.hasKeyValue(arr, key, value)) {
-      arr.push(self.init({ key, value }))
+      arr.push(this.init({ key, value }))
     }
     return arr
   }
-
   static appendRecord(arr = [], key, value) {
     return arr.map((item) => {
-      if (item.key === key) {
+      if (this.sameKey(item, key)) {
         item.value = [...item.value, ...value]
       }
       return item
     })
   }
-
-  static fromObject(options = {}) {
-    const self = this
-    return Object.keys(options).reduce((acc, key) => {
-      acc.push(self.init({ key, value: options[key] }))
-      return acc
-    }, [])
-  }
-
-  static removeByKey(arr, key) {
-    return arr.reduce((acc, item) => {
-      if (item.key !== key) {
-        acc.push(item)
+  static appendValueArray(arr = [], key, value) {
+    return arr.map((item) => {
+      if (this.sameKey(item, key)) {
+        item.value = [...item.value, ...value]
       }
-      return acc
-    }, [])
+      return item
+    })
   }
-
   static foundByKey(arr = [], key) {
     const found = arr.find((m) => {
-      return m.key === key
+      return this.sameKey(m, key)
     })
     return found || null
   }
-
   static foundValueByKey(arr = [], key) {
     const found = this.foundByKey(arr, key)
     return found ? found.value : null
   }
-
+  static fromObject(options = {}) {
+    return Object.keys(options).reduce((acc, key) => {
+      acc.push(this.init({ key, value: options[key] }))
+      return acc
+    }, [])
+  }
   static getValueByKey(arr = [], key) {
-    const found = arr.find((i) => {
-      return i.key === key
-    })
-    if (found) {
-      return found.value
-    }
-    return null
+    return this.foundValueByKey(arr, key)
   }
-
   static getValueByKeyFromArray(arr = [], key) {
     if (arr.length === 0) {
       return null
     }
     const firstArr = arr.shift()
     const found = firstArr.find((i) => {
-      return i.key === key
+      return this.sameKey(i, key)
     })
     if (found && found.value) {
       return found.value
     }
     return this.getValueByKeyFromArray(arr, key)
   }
-
   static getValuesByKey(arr = [], key) {
     return arr.reduce((acc, item) => {
-      if (item.key === key) {
+      if (this.sameKey(item, key)) {
         acc.push(item.value)
       }
       return acc
     }, [])
   }
-
   static hasKeyValue(arr = [], key, value) {
     if (typeof value === 'undefined') {
-      return arr.filter((item) => item.key === key).length > 0
+      return arr.filter((item) => this.sameKey(item, key)).length > 0
     }
-    return arr.filter((item) => (item.key === key && item.value === value)).length > 0
+    return arr.filter((item) => (this.sameKey(item, key) && item.value === value)).length > 0
   }
-
   static insertOrUpdateRecord(arr = [], key, value) {
-    const self = this
     let copy = [...arr]
-    if (!self.hasKeyValue(arr, key)) {
-      copy.push(self.init({ key, value }))
+    if (!this.hasKeyValue(arr, key)) {
+      copy.push(this.init({ key, value }))
     } else {
-      copy = self.updateRecord(arr, key, value)
+      copy = this.updateRecord(arr, key, value)
     }
     return copy
   }
-
   static keys(arr = []) {
     if (Array.isArray(arr)) {
       return arr.reduce((acc, item) => {
@@ -525,7 +607,6 @@ class KeyValueObject {
     }
     return []
   }
-
   static merge(toArr, fromArr) {
     (fromArr || []).map((from) => {
       const found = toArr.find((to) => {
@@ -539,7 +620,17 @@ class KeyValueObject {
     })
     return toArr
   }
-
+  static removeByKey(arr, key) {
+    return arr.reduce((acc, item) => {
+      if (!this.sameKey(item, key)) {
+        acc.push(item)
+      }
+      return acc
+    }, [])
+  }
+  static sameKey(item, key) {
+    return item.key === key
+  }
   static toObject(arr = []) {
     if (Array.isArray(arr)) {
       return arr.reduce((acc, item) => {
@@ -549,7 +640,6 @@ class KeyValueObject {
     }
     return {}
   }
-
   static toString(arr = [], delimiter = '; ') {
     if (Array.isArray(arr)) {
       return arr.reduce((acc, item) => {
@@ -559,10 +649,9 @@ class KeyValueObject {
     }
     return ''
   }
-
   static updateRecord(arr = [], key, value) {
     return arr.map((item) => {
-      if (item.key === key) {
+      if (this.sameKey(item, key)) {
         return {
           ...item,
           value
@@ -571,11 +660,9 @@ class KeyValueObject {
       return item
     })
   }
-
   static updateOrInsertRecord(arr = [], key, value) {
     return this.insertOrUpdateRecord(arr, key, value)
   }
-
   static updateRecordsFromArray(arr = [], updateArr = []) {
     if (Array.isArray(arr) && Array.isArray(updateArr)) {
       const obj1 = this.toObject(arr)
@@ -587,7 +674,6 @@ class KeyValueObject {
     }
     return []
   }
-
   static values(arr = []) {
     if (Array.isArray(arr)) {
       return arr.reduce((acc, item) => {
@@ -619,6 +705,13 @@ class KeyValueObject {
 
 
 
+;// ./lib/helpers/stringFormatter/stringFormatter.js
+function stringFormatter(str) {
+  return (str || '').toUpperCase().replace('-', '_').replace(' ', '_')
+}
+
+
+
 ;// ./lib/models/metadata/metadata.js
 
 
@@ -634,16 +727,25 @@ class Metadata extends KeyValueObject {
     })
     return instance.isValid ? instance : null
   }
+  static get _classname() {
+    return 'Metadata'
+  }
 
-  static foundByKey(arr = [], key) {
-    const found = (arr || []).find((m) => {
-      return m.key === stringFormatter(key)
+  static merge(toArr, fromArr) {
+    (fromArr || []).map((from) => {
+      const found = toArr.find((to) => {
+        return stringFormatter(to.key) === stringFormatter(from.key)
+      })
+      if (found) {
+        found.value = (found.value || []).concat(from.value)
+      } else {
+        toArr.push(from)
+      }
     })
-    return found || null
+    return toArr
   }
-
-  static get _classname() {
-    return 'Metadata'
+  static sameKey(item, key) {
+    return stringFormatter(item.key) === stringFormatter(key)
   }
 }
 
@@ -790,68 +892,112 @@ class Repo {
     }
   }
 
-  findAll({ query }) {
+  // systemLog is optional
+  findAll({ query, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_READ',
+      message: `fn ${this._classname}.prototype.findAll`,
+      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
+    })
     return new Promise((resolve, reject) => {
       this.model.findAll(query, this.queryOptions, (err, data, total) => {
         if (err) {
+          log({ level: 'warn', output: err.toString() })
           reject(err)
         } else {
-          resolve({
+          const result = {
             isNew: false,
             data,
             total: total || data.length
-          })
+          }
+          log({ level: 'info', output: { ...result } })
+          resolve(result)
         }
       })
     })
   }
 
-  findOne({ query }) {
+  findOne({ query, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_READ',
+      message: `fn ${this._classname}.prototype.findOne`,
+      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
+    })
     return new Promise((resolve, reject) => {
       this.model.findAll(query, this.queryOptions, (err, data) => {
         if (err) {
           reject(err)
         } else if (data.length === 1) {
-          resolve({
+          const result = {
             isNew: false,
             data,
             total: 1
-          })
+          }
+          log({ level: 'info', output: { ...result } })
+          resolve(result)
         } else if (data.length === 0) {
           reject(new Error('record not found'))
         } else {
           reject(new Error('more than one is found'))
         }
       })
+        .catch((err) => {
+          log({ level: 'warn', output: err.toString() })
+          throw err
+        })
     })
   }
 
-  saveAll({ docs }) {
+  saveAll({ docs, systemLog }) {
     let isNew
-    return Promise.all(docs.map(async (doc) => {
-      if (doc) {
-        const result = await this.saveOne({ doc })
-        isNew = result.isNew
-        const _data = result._data || result.data
-        return _data[0]
-      }
-      return null
-    })).then((savedData) => {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_WRITE',
+      message: `fn ${this._classname}.prototype.saveAll`,
+      input: [{ docs: [...docs], systemLog: { ...systemLog } }]
+    })
+    const promise = typeof this.model.saveAll === 'function'
+      ? this.model.saveAll({ docs })
+      : Promise.all(docs.map(async (doc) => {
+          if (doc) {
+            const result = await this.saveOne({ doc })
+            isNew = result.isNew
+            const _data = result._data || result.data
+            return _data[0]
+          }
+          return null
+        }))
+    return promise.then((savedData) => {
       if (savedData.length !== 1) isNew = null
-      return {
+      const result = {
         data: savedData,
         isNew,
         total: savedData.length
       }
+      log({ level: 'info', output: { ...result } })
+      return result
+    }).catch((err) => {
+      log({ level: 'warn', output: err.toString() })
+      throw err
     })
   }
 
-  saveOne({ doc }) {
+  saveOne({ doc, systemLog }) {
+    const log = _makeLog({
+      systemLog,
+      label: 'REPO_WRITE',
+      message: `fn ${this._classname}.prototype.saveOne`,
+      input: [{ doc: { ...doc }, systemLog: { ...systemLog } }]
+    })
     return new Promise((resolve, reject) => {
       this.model.saveOne(doc, this.saveOptions, (err, result) => {
         if (err) {
+          log({ level: 'warn', output: err.toString() })
           reject(err)
         } else {
+          log({ level: 'info', output: { ...result } })
           resolve(result)
         }
       })
@@ -859,6 +1005,25 @@ class Repo {
   }
 }
 
+function _makeLog({ systemLog, label, message: message1, input } = {}) {
+  return ({ level, messgae: massage2, output } = {}) => {
+    if (systemLog && systemLog.systemLogHelper) {
+      systemLog.systemLogHelper.log({
+        batchId: systemLog.batchId,
+        label,
+        level,
+        message: massage2 || message1,
+        data: {
+          payload: {
+            input,
+            output
+          }
+        }
+      })
+    }
+  }
+}
+
 
 
 ;// ./lib/models/repo/index.js
@@ -889,16 +1054,16 @@ class Service {
       })
   }
 
-  async findAll({ query = {} } = {}) {
-    const result = await this.repo.findAll({ query })
+  async findAll({ query = {}, systemLog } = {}) {
+    const result = await this.repo.findAll({ query, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
     })
   }
 
-  async findOne({ query = {} } = {}) {
-    const result = await this.repo.findOne({ query })
+  async findOne({ query = {}, systemLog } = {}) {
+    const result = await this.repo.findOne({ query, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
@@ -912,21 +1077,21 @@ class Service {
     return arr.map((i) => this.init(i))
   }
 
-  async saveAll({ docs = [] } = {}) {
+  async saveAll({ docs = [], systemLog } = {}) {
     const copies = docs.map((doc) => {
       return this.init(doc)
     })
-    const result = await this.repo.saveAll({ docs: copies })
+    const result = await this.repo.saveAll({ docs: copies, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
     })
   }
 
-  async saveOne({ doc = {} } = {}) {
+  async saveOne({ doc = {}, systemLog } = {}) {
     const copy = this.init(doc)
     if (copy) {
-      const result = await this.repo.saveOne({ doc: copy })
+      const result = await this.repo.saveOne({ doc: copy, systemLog })
       return makeApiResponse({
         repo: this.repo,
         result
@@ -957,6 +1122,54 @@ function makeService({ repo }) {
 
 
 
+;// ./lib/models/uniqueKeyGenerator/uniqueKeyGenerator.js
+
+
+class UniqueKeyGenerator {
+  static get _classname() {
+    return 'UniqueKeyGenerator'
+  }
+  static get _superclass() {
+    return 'UniqueKeyGenerator'
+  }
+  static makeFormatter({ fieldName, format, options }) {
+    switch (format) {
+      case 'set_code':
+        return _makeSetCode(fieldName, options)
+      default:
+        return _makeSetCode(fieldName, options)
+    }
+  }
+  static makeGenerator(arr) {
+    const fns = arr.map((item) => this.makeFormatter(item))
+    return async (obj) => {
+      const output = await pReduce(fns, async (acc, fn) => {
+        const _obj = await fn(obj)
+        return Object.assign(acc, _obj)
+      }, obj)
+      return output
+    }
+  }
+}
+
+function _makeSetCode(fieldName, options) {
+  return async (obj = {}) => {
+    if (obj[fieldName]) {
+      return {}
+    }
+    return {
+      [fieldName]: stringHelper.setCode()
+    }
+  }
+}
+
+
+
+;// ./lib/models/uniqueKeyGenerator/index.js
+
+
+
+
 ;// ./lib/models/index.js
 
 
@@ -965,6 +1178,193 @@ function makeService({ repo }) {
 
 
 
+
+;// ./lib/helpers/generalPost/generalPost.js
+
+
+
+
+async function generalPost({ body = {}, GeneralModel, UniqueKeyGenerator, resourceInfo }) {
+  const { resources, data, globalShared = {}, shared = {}, relationship = {} } = body
+  const _resourceInfo = resourceInfo || body.resourceInfo
+  _attachShared(data, globalShared, shared)
+  const obj = await pReduce(resources, async (acc, resource) => {
+    const service = _makeService(resource, _resourceInfo, UniqueKeyGenerator, GeneralModel)
+    _createRelationship(data, relationship[resource], acc)
+    const _data = data[resource]
+    const result = await service.saveAll({ docs: [].concat(_data) })
+    acc[resource] = Array.isArray(_data) ? result._data : result._data[0]
+    return acc
+  }, {})
+  return obj
+}
+
+function _attachShared(data, globalShared = {}, shared = {}) {
+  Object.keys(shared).forEach((key) => {
+    const _data = data[key]
+    data[key] = objectHelper.merge({}, _data, globalShared, shared[key] || {})
+  })
+}
+
+function _createRelationship(data, relationship = {}, object) {
+  Object.keys(relationship).forEach((key) => {
+    const path = relationship[key]
+    const val = objectHelper.get(object, path)
+    objectHelper.set(data, key, val)
+  })
+}
+
+function _makeService(resource, resourceInfo, UniqueKeyGenerator, GeneralModel) {
+  const { collectionName, fields } = resourceInfo[resource]
+  const uniqueKeyGenerator = UniqueKeyGenerator.makeGenerator(fields)
+  const model = new GeneralModel({ collectionName, uniqueKeyGenerator })
+  return makeService({
+    repo: new Repo({ model })
+  })
+}
+
+
+
+;// ./lib/helpers/generalPost/index.js
+
+
+
+
+;// ./lib/helpers/padZeros/padZeros.js
+function padZeros(num, minLength = 6) {
+  num = num.toString()
+  if (num.length < minLength) {
+    return padZeros('0' + num, minLength)
+  }
+  return num
+}
+
+
+
+;// ./lib/helpers/padZeros/index.js
+
+
+
+
+;// ./lib/helpers/pReduce/index.js
+
+
+
+
+;// ./lib/helpers/stringFormatter/index.js
+
+
+
+
+;// ./lib/helpers/stringHelper/stringHelper.js
+function baseXEncode(num, base = 34) {
+  const charset = getBaseCharset(base)
+  return encode(num, charset)
+}
+
+function encode(int, charset) {
+  let byCode = charset.byCode;
+  if (int === 0) {
+      return byCode[0];
+  }
+
+  var res = "",
+      max = charset.length;
+  while (int > 0) {
+      res = byCode[int % max] + res;
+      int = Math.floor(int / max);
+  }
+  return res;
+}
+
+function getBaseCharset(base) {
+  let charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZ'
+  if (base === 58) {
+    charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz'
+  }
+  return indexCharset(charset)
+}
+
+function indexCharset(str) {
+  var byCode = {},
+      byChar = {},
+      length = str.length,
+      i, char;
+  for (i = 0; i < length; i++) {
+      char = str[i];
+      byCode[i] = char;
+      byChar[char] = i;
+  }
+  return { byCode: byCode, byChar: byChar, length: length };
+}
+
+function randomString({ len = 16, pattern = 'a1' } = {}) {
+  const A = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+  const a = 'abcdefghijklmnopqrstuvwxyz'
+  const num = '1234567890'
+  const mark = '~!@#$%^&*_+-='
+  let str = ''
+  if (pattern.includes('A')) {
+    str += A
+  }
+  if (pattern.includes('a')) {
+    str += a
+  }
+  if (pattern.includes('1')) {
+    str += num
+  }
+  if (pattern.includes('#')) {
+    str += mark
+  }
+  const chars = [...str]
+  return [...Array(len)].map(i => {
+    return chars[(Math.random() * chars.length) | 0]
+  }).join``
+}
+
+function reverse(str) {
+  if (typeof str !== 'string') {
+    str = str.toString()
+  }
+  const splitString = str.split('')
+  const reverseArray = splitString.reverse()
+  return reverseArray.join('')
+}
+
+function setCode(base = 34) {
+  const now = (new Date()).valueOf()
+  const random = randomString({
+    len: 8,
+    pattern: '1'
+  })
+  const str = reverse(`${now}${random}`)
+  // const str = `${now}${random}`
+  return baseXEncode(str, base)
+}
+
+const stringHelper = {
+  setCode
+}
+
+
+;// ./lib/helpers/stringHelper/index.js
+
+
+
+
+
+;// ./lib/helpers/index.js
+
+
+
+
+
+
+
+
+
+
+
 ;// ./lib/index.js