@questwork/q-utilities 0.1.24 → 0.1.30

package/.github/workflows/publish.yml

@@ -5,16 +5,12 @@ on:
       - 'v*'
   workflow_dispatch:
 
-permissions:
-  id-token: write  # Required for OIDC
-  contents: read
-
 jobs:
   publish:
     runs-on: ubuntu-latest
     permissions:
       contents: read
-      packages: write
+      id-token: write  # OIDC
     # environment: production
     steps:
       - uses: actions/checkout@v4
@@ -51,7 +47,14 @@ jobs:
       #     NODE_AUTH_TOKEN: ${{ secrets.QW_NPM_TOKEN }}
           
       - name: Update npm
-        run: npm install -g npm@latest
+        run: |
+          NPM_VERSION=$(npm -v)
+          echo "Current npm version: $NPM_VERSION"
+          if ! npx semver -r ">=11.5.1" "$NPM_VERSION"; then
+            echo "npm version $NPM_VERSION is too old. Installing latest npm..."
+            npm install -g npm@latest
+            echo "Updated npm version: $(npm -v)"
+          fi
 
       - name: Publish to npm
-        run: npm publish --access public
+        run: npm publish --no-git-checks --access public

package/dist/index.min.cjs

@@ -89,6 +89,9 @@ __webpack_require__.d(__webpack_exports__, {
   makeService: () => (/* reexport */ makeService),
   mergeArraysByKey: () => (/* reexport */ mergeArraysByKey),
   objectHelper: () => (/* reexport */ objectHelper),
+  pMap: () => (/* reexport */ pMap),
+  pMapIterable: () => (/* reexport */ pMapIterable),
+  pMapSkip: () => (/* reexport */ pMapSkip),
   pReduce: () => (/* reexport */ pReduce),
   padZeros: () => (/* reexport */ padZeros),
   printControlCharReport: () => (/* reexport */ printControlCharReport),
@@ -1349,15 +1352,19 @@ class Repo {
   }
 
   // systemLog is optional
-  findAll({ query, systemLog }) {
+  findAll({ config = {}, query, systemLog }) {
     const log = _makeLog({
       systemLog,
       label: 'REPO_READ',
       message: `fn ${this._classname}.prototype.findAll`,
       input: [{ query: { ...query }, systemLog: { ...systemLog } }]
     })
+    const queryOptions = {
+      ...this.queryOptions,
+      ...config,
+    }
     return new Promise((resolve, reject) => {
-      this.model.findAll(query, this.queryOptions, (err, data, total) => {
+      this.model.findAll(query, queryOptions, (err, data, total) => {
         if (err) {
           log({ level: 'warn', output: err.toString() })
           reject(err)
@@ -1374,15 +1381,19 @@ class Repo {
     })
   }
 
-  findOne({ query, systemLog }) {
+  findOne({ config = {}, query, systemLog }) {
     const log = _makeLog({
       systemLog,
       label: 'REPO_READ',
       message: `fn ${this._classname}.prototype.findOne`,
       input: [{ query: { ...query }, systemLog: { ...systemLog } }]
     })
+    const queryOptions = {
+      ...this.queryOptions,
+      ...config,
+    }
     return new Promise((resolve, reject) => {
-      this.model.findAll(query, this.queryOptions, (err, data) => {
+      this.model.findAll(query, queryOptions, (err, data) => {
         if (err) {
           reject(err)
         } else if (data.length === 1) {
@@ -1416,15 +1427,16 @@ class Repo {
     })
     const promise = typeof this.model.saveAll === 'function'
       ? this.model.saveAll({ config, docs })
-      : Promise.all(docs.map(async (doc) => {
-          if (doc) {
-            const result = await this.saveOne({ config, doc })
-            isNew = result.isNew
-            const _data = result._data || result.data
-            return _data[0]
-          }
-          return null
-        }))
+      : _saveAll({ config, docs, service: this })
+    // : Promise.all(docs.map(async (doc) => {
+    //     if (doc) {
+    //       const result = await this.saveOne({ config, doc })
+    //       isNew = result.isNew
+    //       const _data = result._data || result.data
+    //       return _data[0]
+    //     }
+    //     return null
+    //   }))
     return promise.then((savedData) => {
       if (savedData.length !== 1)
         isNew = null
@@ -1485,6 +1497,32 @@ function _makeLog({ systemLog, label, message: message1, input } = {}) {
   }
 }
 
+async function _saveAll({ config = {}, docs, service }) {
+  let _result = null
+  if (config.session || service.saveOptions.session) {
+    _result = await pMap(docs, async (doc) => {
+      if (doc) {
+        const result = await service.saveOne({ config, doc })
+        // isNew = result.isNew
+        const _data = result._data || result.data
+        return _data[0]
+      }
+      return null
+    }, { concurrency: 1 })
+  } else {
+    _result = await Promise.all(docs.map(async (doc) => {
+      if (doc) {
+        const result = await service.saveOne({ config, doc })
+        // isNew = result.isNew
+        const _data = result._data || result.data
+        return _data[0]
+      }
+      return null
+    }))
+  }
+  return _result
+}
+
 
 
 ;// ./lib/models/repo/index.js
@@ -1520,16 +1558,16 @@ class Service {
     //   })
   }
 
-  async findAll({ query = {}, systemLog } = {}) {
-    const result = await this.repo.findAll({ query, systemLog })
+  async findAll({ config = {}, query = {}, systemLog } = {}) {
+    const result = await this.repo.findAll({ config, query, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
     })
   }
 
-  async findOne({ query = {}, systemLog } = {}) {
-    const result = await this.repo.findOne({ query, systemLog })
+  async findOne({ config = {}, query = {}, systemLog } = {}) {
+    const result = await this.repo.findOne({ config, query, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
@@ -3899,6 +3937,293 @@ function padZeros(num, minLength = 6) {
 
 
 
+;// ./lib/helpers/pMap/pMap.js
+async function pMap(
+  iterable,
+  mapper,
+  {
+    concurrency = Number.POSITIVE_INFINITY,
+    stopOnError = true,
+    signal,
+  } = {},
+) {
+  return new Promise((resolve_, reject_) => {
+    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`)
+    }
+
+    if (typeof mapper !== 'function') {
+      throw new TypeError('Mapper function is required')
+    }
+
+    if (!((Number.isSafeInteger(concurrency) && concurrency >= 1) || concurrency === Number.POSITIVE_INFINITY)) {
+      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`)
+    }
+
+    const result = []
+    const errors = []
+    const skippedIndexesMap = new Map()
+    let isRejected = false
+    let isResolved = false
+    let isIterableDone = false
+    let resolvingCount = 0
+    let currentIndex = 0
+    const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]()
+
+    const signalListener = () => {
+      reject(signal.reason)
+    }
+
+    const cleanup = () => {
+      signal?.removeEventListener('abort', signalListener)
+    }
+
+    const resolve = (value) => {
+      resolve_(value)
+      cleanup()
+    }
+
+    const reject = (reason) => {
+      isRejected = true
+      isResolved = true
+      reject_(reason)
+      cleanup()
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(signal.reason)
+      }
+
+      signal.addEventListener('abort', signalListener, { once: true })
+    }
+
+    const next = async () => {
+      if (isResolved) {
+        return
+      }
+
+      const nextItem = await iterator.next()
+
+      const index = currentIndex
+      currentIndex++
+
+      // Note: `iterator.next()` can be called many times in parallel.
+      // This can cause multiple calls to this `next()` function to
+      // receive a `nextItem` with `done === true`.
+      // The shutdown logic that rejects/resolves must be protected
+      // so it runs only one time as the `skippedIndex` logic is
+      // non-idempotent.
+      if (nextItem.done) {
+        isIterableDone = true
+
+        if (resolvingCount === 0 && !isResolved) {
+          if (!stopOnError && errors.length > 0) {
+            reject(new AggregateError(errors)) // eslint-disable-line unicorn/error-message
+            return
+          }
+
+          isResolved = true
+
+          if (skippedIndexesMap.size === 0) {
+            resolve(result)
+            return
+          }
+
+          const pureResult = []
+
+          // Support multiple `pMapSkip`'s.
+          for (const [index, value] of result.entries()) {
+            if (skippedIndexesMap.get(index) === pMapSkip) {
+              continue
+            }
+
+            pureResult.push(value)
+          }
+
+          resolve(pureResult)
+        }
+
+        return
+      }
+
+      resolvingCount++;
+
+      // Intentionally detached
+      (async () => {
+        try {
+          const element = await nextItem.value
+
+          if (isResolved) {
+            return
+          }
+
+          const value = await mapper(element, index)
+
+          // Use Map to stage the index of the element.
+          if (value === pMapSkip) {
+            skippedIndexesMap.set(index, value)
+          }
+
+          result[index] = value
+
+          resolvingCount--
+          await next()
+        } catch (error) {
+          if (stopOnError) {
+            reject(error)
+          } else {
+            errors.push(error)
+            resolvingCount--
+
+            // In that case we can't really continue regardless of `stopOnError` state
+            // since an iterable is likely to continue throwing after it throws once.
+            // If we continue calling `next()` indefinitely we will likely end up
+            // in an infinite loop of failed iteration.
+            try {
+              await next()
+            } catch (error) {
+              reject(error)
+            }
+          }
+        }
+      })()
+    };
+
+    // Create the concurrent runners in a detached (non-awaited)
+    // promise. We need this so we can await the `next()` calls
+    // to stop creating runners before hitting the concurrency limit
+    // if the iterable has already been marked as done.
+    // NOTE: We *must* do this for async iterators otherwise we'll spin up
+    // infinite `next()` calls by default and never start the event loop.
+    (async () => {
+      for (let index = 0; index < concurrency; index++) {
+        try {
+          await next()
+        } catch (error) {
+          reject(error)
+          break
+        }
+
+        if (isIterableDone || isRejected) {
+          break
+        }
+      }
+    })()
+  })
+}
+
+function pMapIterable(
+  iterable,
+  mapper,
+  {
+    concurrency = Number.POSITIVE_INFINITY,
+    backpressure = concurrency,
+  } = {},
+) {
+  if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+    throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`)
+  }
+
+  if (typeof mapper !== 'function') {
+    throw new TypeError('Mapper function is required')
+  }
+
+  if (!((Number.isSafeInteger(concurrency) && concurrency >= 1) || concurrency === Number.POSITIVE_INFINITY)) {
+    throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`)
+  }
+
+  if (!((Number.isSafeInteger(backpressure) && backpressure >= concurrency) || backpressure === Number.POSITIVE_INFINITY)) {
+    throw new TypeError(`Expected \`backpressure\` to be an integer from \`concurrency\` (${concurrency}) and up or \`Infinity\`, got \`${backpressure}\` (${typeof backpressure})`)
+  }
+
+  return {
+    async* [Symbol.asyncIterator]() {
+      const iterator = iterable[Symbol.asyncIterator] === undefined ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]()
+
+      const promises = []
+      let pendingPromisesCount = 0
+      let isDone = false
+      let index = 0
+
+      function trySpawn() {
+        if (isDone || !(pendingPromisesCount < concurrency && promises.length < backpressure)) {
+          return
+        }
+
+        pendingPromisesCount++
+
+        const promise = (async () => {
+          const { done, value } = await iterator.next()
+
+          if (done) {
+            pendingPromisesCount--
+            return { done: true }
+          }
+
+          // Spawn if still below concurrency and backpressure limit
+          trySpawn()
+
+          try {
+            const returnValue = await mapper(await value, index++)
+
+            pendingPromisesCount--
+
+            if (returnValue === pMapSkip) {
+              const index = promises.indexOf(promise)
+
+              if (index > 0) {
+                promises.splice(index, 1)
+              }
+            }
+
+            // Spawn if still below backpressure limit and just dropped below concurrency limit
+            trySpawn()
+
+            return { done: false, value: returnValue }
+          } catch (error) {
+            pendingPromisesCount--
+            isDone = true
+            return { error }
+          }
+        })()
+
+        promises.push(promise)
+      }
+
+      trySpawn()
+
+      while (promises.length > 0) {
+        const { error, done, value } = await promises[0]
+
+        promises.shift()
+
+        if (error) {
+          throw error
+        }
+
+        if (done) {
+          return
+        }
+
+        // Spawn if just dropped below backpressure limit and below the concurrency limit
+        trySpawn()
+
+        if (value === pMapSkip) {
+          continue
+        }
+
+        yield value
+      }
+    },
+  }
+}
+
+const pMapSkip = Symbol('skip')
+
+;// ./lib/helpers/pMap/index.js
+
+
 ;// ./lib/helpers/pReduce/index.js
 
 
@@ -4255,11 +4580,19 @@ function toLowerCase(str) {
     .toLowerCase()
 }
 
+function toScreamingSnakeCase(str) {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    .toUpperCase()
+}
+
 const stringHelper = {
   isSame,
   setCode,
   toCamelCase,
   toLowerCase,
+  toScreamingSnakeCase,
 }
 
 
@@ -4395,6 +4728,7 @@ function tenantPlugin(schema, options) {
 
 
 
+
 
 
 ;// ./lib/index.js

package/dist/q-utilities.esm.js

@@ -1274,15 +1274,19 @@ class Repo {
   }
 
   // systemLog is optional
-  findAll({ query, systemLog }) {
+  findAll({ config = {}, query, systemLog }) {
     const log = _makeLog({
       systemLog,
       label: 'REPO_READ',
       message: `fn ${this._classname}.prototype.findAll`,
       input: [{ query: { ...query }, systemLog: { ...systemLog } }]
     })
+    const queryOptions = {
+      ...this.queryOptions,
+      ...config,
+    }
     return new Promise((resolve, reject) => {
-      this.model.findAll(query, this.queryOptions, (err, data, total) => {
+      this.model.findAll(query, queryOptions, (err, data, total) => {
         if (err) {
           log({ level: 'warn', output: err.toString() })
           reject(err)
@@ -1299,15 +1303,19 @@ class Repo {
     })
   }
 
-  findOne({ query, systemLog }) {
+  findOne({ config = {}, query, systemLog }) {
     const log = _makeLog({
       systemLog,
       label: 'REPO_READ',
       message: `fn ${this._classname}.prototype.findOne`,
       input: [{ query: { ...query }, systemLog: { ...systemLog } }]
     })
+    const queryOptions = {
+      ...this.queryOptions,
+      ...config,
+    }
     return new Promise((resolve, reject) => {
-      this.model.findAll(query, this.queryOptions, (err, data) => {
+      this.model.findAll(query, queryOptions, (err, data) => {
         if (err) {
           reject(err)
         } else if (data.length === 1) {
@@ -1341,15 +1349,16 @@ class Repo {
     })
     const promise = typeof this.model.saveAll === 'function'
       ? this.model.saveAll({ config, docs })
-      : Promise.all(docs.map(async (doc) => {
-          if (doc) {
-            const result = await this.saveOne({ config, doc })
-            isNew = result.isNew
-            const _data = result._data || result.data
-            return _data[0]
-          }
-          return null
-        }))
+      : _saveAll({ config, docs, service: this })
+    // : Promise.all(docs.map(async (doc) => {
+    //     if (doc) {
+    //       const result = await this.saveOne({ config, doc })
+    //       isNew = result.isNew
+    //       const _data = result._data || result.data
+    //       return _data[0]
+    //     }
+    //     return null
+    //   }))
     return promise.then((savedData) => {
       if (savedData.length !== 1)
         isNew = null
@@ -1410,6 +1419,32 @@ function _makeLog({ systemLog, label, message: message1, input } = {}) {
   }
 }
 
+async function _saveAll({ config = {}, docs, service }) {
+  let _result = null
+  if (config.session || service.saveOptions.session) {
+    _result = await pMap(docs, async (doc) => {
+      if (doc) {
+        const result = await service.saveOne({ config, doc })
+        // isNew = result.isNew
+        const _data = result._data || result.data
+        return _data[0]
+      }
+      return null
+    }, { concurrency: 1 })
+  } else {
+    _result = await Promise.all(docs.map(async (doc) => {
+      if (doc) {
+        const result = await service.saveOne({ config, doc })
+        // isNew = result.isNew
+        const _data = result._data || result.data
+        return _data[0]
+      }
+      return null
+    }))
+  }
+  return _result
+}
+
 
 
 ;// ./lib/models/repo/index.js
@@ -1445,16 +1480,16 @@ class Service {
     //   })
   }
 
-  async findAll({ query = {}, systemLog } = {}) {
-    const result = await this.repo.findAll({ query, systemLog })
+  async findAll({ config = {}, query = {}, systemLog } = {}) {
+    const result = await this.repo.findAll({ config, query, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
     })
   }
 
-  async findOne({ query = {}, systemLog } = {}) {
-    const result = await this.repo.findOne({ query, systemLog })
+  async findOne({ config = {}, query = {}, systemLog } = {}) {
+    const result = await this.repo.findOne({ config, query, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
@@ -3824,6 +3859,293 @@ function padZeros(num, minLength = 6) {
 
 
 
+;// ./lib/helpers/pMap/pMap.js
+async function pMap(
+  iterable,
+  mapper,
+  {
+    concurrency = Number.POSITIVE_INFINITY,
+    stopOnError = true,
+    signal,
+  } = {},
+) {
+  return new Promise((resolve_, reject_) => {
+    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`)
+    }
+
+    if (typeof mapper !== 'function') {
+      throw new TypeError('Mapper function is required')
+    }
+
+    if (!((Number.isSafeInteger(concurrency) && concurrency >= 1) || concurrency === Number.POSITIVE_INFINITY)) {
+      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`)
+    }
+
+    const result = []
+    const errors = []
+    const skippedIndexesMap = new Map()
+    let isRejected = false
+    let isResolved = false
+    let isIterableDone = false
+    let resolvingCount = 0
+    let currentIndex = 0
+    const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]()
+
+    const signalListener = () => {
+      reject(signal.reason)
+    }
+
+    const cleanup = () => {
+      signal?.removeEventListener('abort', signalListener)
+    }
+
+    const resolve = (value) => {
+      resolve_(value)
+      cleanup()
+    }
+
+    const reject = (reason) => {
+      isRejected = true
+      isResolved = true
+      reject_(reason)
+      cleanup()
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(signal.reason)
+      }
+
+      signal.addEventListener('abort', signalListener, { once: true })
+    }
+
+    const next = async () => {
+      if (isResolved) {
+        return
+      }
+
+      const nextItem = await iterator.next()
+
+      const index = currentIndex
+      currentIndex++
+
+      // Note: `iterator.next()` can be called many times in parallel.
+      // This can cause multiple calls to this `next()` function to
+      // receive a `nextItem` with `done === true`.
+      // The shutdown logic that rejects/resolves must be protected
+      // so it runs only one time as the `skippedIndex` logic is
+      // non-idempotent.
+      if (nextItem.done) {
+        isIterableDone = true
+
+        if (resolvingCount === 0 && !isResolved) {
+          if (!stopOnError && errors.length > 0) {
+            reject(new AggregateError(errors)) // eslint-disable-line unicorn/error-message
+            return
+          }
+
+          isResolved = true
+
+          if (skippedIndexesMap.size === 0) {
+            resolve(result)
+            return
+          }
+
+          const pureResult = []
+
+          // Support multiple `pMapSkip`'s.
+          for (const [index, value] of result.entries()) {
+            if (skippedIndexesMap.get(index) === pMapSkip) {
+              continue
+            }
+
+            pureResult.push(value)
+          }
+
+          resolve(pureResult)
+        }
+
+        return
+      }
+
+      resolvingCount++;
+
+      // Intentionally detached
+      (async () => {
+        try {
+          const element = await nextItem.value
+
+          if (isResolved) {
+            return
+          }
+
+          const value = await mapper(element, index)
+
+          // Use Map to stage the index of the element.
+          if (value === pMapSkip) {
+            skippedIndexesMap.set(index, value)
+          }
+
+          result[index] = value
+
+          resolvingCount--
+          await next()
+        } catch (error) {
+          if (stopOnError) {
+            reject(error)
+          } else {
+            errors.push(error)
+            resolvingCount--
+
+            // In that case we can't really continue regardless of `stopOnError` state
+            // since an iterable is likely to continue throwing after it throws once.
+            // If we continue calling `next()` indefinitely we will likely end up
+            // in an infinite loop of failed iteration.
+            try {
+              await next()
+            } catch (error) {
+              reject(error)
+            }
+          }
+        }
+      })()
+    };
+
+    // Create the concurrent runners in a detached (non-awaited)
+    // promise. We need this so we can await the `next()` calls
+    // to stop creating runners before hitting the concurrency limit
+    // if the iterable has already been marked as done.
+    // NOTE: We *must* do this for async iterators otherwise we'll spin up
+    // infinite `next()` calls by default and never start the event loop.
+    (async () => {
+      for (let index = 0; index < concurrency; index++) {
+        try {
+          await next()
+        } catch (error) {
+          reject(error)
+          break
+        }
+
+        if (isIterableDone || isRejected) {
+          break
+        }
+      }
+    })()
+  })
+}
+
+function pMapIterable(
+  iterable,
+  mapper,
+  {
+    concurrency = Number.POSITIVE_INFINITY,
+    backpressure = concurrency,
+  } = {},
+) {
+  if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+    throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`)
+  }
+
+  if (typeof mapper !== 'function') {
+    throw new TypeError('Mapper function is required')
+  }
+
+  if (!((Number.isSafeInteger(concurrency) && concurrency >= 1) || concurrency === Number.POSITIVE_INFINITY)) {
+    throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`)
+  }
+
+  if (!((Number.isSafeInteger(backpressure) && backpressure >= concurrency) || backpressure === Number.POSITIVE_INFINITY)) {
+    throw new TypeError(`Expected \`backpressure\` to be an integer from \`concurrency\` (${concurrency}) and up or \`Infinity\`, got \`${backpressure}\` (${typeof backpressure})`)
+  }
+
+  return {
+    async* [Symbol.asyncIterator]() {
+      const iterator = iterable[Symbol.asyncIterator] === undefined ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]()
+
+      const promises = []
+      let pendingPromisesCount = 0
+      let isDone = false
+      let index = 0
+
+      function trySpawn() {
+        if (isDone || !(pendingPromisesCount < concurrency && promises.length < backpressure)) {
+          return
+        }
+
+        pendingPromisesCount++
+
+        const promise = (async () => {
+          const { done, value } = await iterator.next()
+
+          if (done) {
+            pendingPromisesCount--
+            return { done: true }
+          }
+
+          // Spawn if still below concurrency and backpressure limit
+          trySpawn()
+
+          try {
+            const returnValue = await mapper(await value, index++)
+
+            pendingPromisesCount--
+
+            if (returnValue === pMapSkip) {
+              const index = promises.indexOf(promise)
+
+              if (index > 0) {
+                promises.splice(index, 1)
+              }
+            }
+
+            // Spawn if still below backpressure limit and just dropped below concurrency limit
+            trySpawn()
+
+            return { done: false, value: returnValue }
+          } catch (error) {
+            pendingPromisesCount--
+            isDone = true
+            return { error }
+          }
+        })()
+
+        promises.push(promise)
+      }
+
+      trySpawn()
+
+      while (promises.length > 0) {
+        const { error, done, value } = await promises[0]
+
+        promises.shift()
+
+        if (error) {
+          throw error
+        }
+
+        if (done) {
+          return
+        }
+
+        // Spawn if just dropped below backpressure limit and below the concurrency limit
+        trySpawn()
+
+        if (value === pMapSkip) {
+          continue
+        }
+
+        yield value
+      }
+    },
+  }
+}
+
+const pMapSkip = Symbol('skip')
+
+;// ./lib/helpers/pMap/index.js
+
+
 ;// ./lib/helpers/pReduce/index.js
 
 
@@ -4180,11 +4502,19 @@ function toLowerCase(str) {
     .toLowerCase()
 }
 
+function toScreamingSnakeCase(str) {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    .toUpperCase()
+}
+
 const stringHelper = {
   isSame,
   setCode,
   toCamelCase,
   toLowerCase,
+  toScreamingSnakeCase,
 }
 
 
@@ -4320,6 +4650,7 @@ function tenantPlugin(schema, options) {
 
 
 
+
 
 
 ;// ./lib/index.js
@@ -4329,4 +4660,4 @@ function tenantPlugin(schema, options) {
 ;// ./index.js
 
 
-export { ActionRecord, ApiResponse, AwsStsS3Client, keyValueObject_KeyValueObject as KeyValueObject, Metadata, PushEnvelope, QMeta, Repo, Service, Status, StatusDocument, TemplateCompiler, TenantAwareEntity, TrackedEntity, UniqueKeyGenerator, authorize, bwipJsHelper, calculateAge, changeCreatorOwner, concatStringByArray, convertString, detectControlCharacters, downloadFileByUrl, escapeRegex, expressHelper, extractEmails, formatDate, generalPost, getObjectByArr, getValidation, getValueByKeys_getValueByKeys as getValueByKeys, groupArrayByKey, init, initFromArray, initOnlyValidFromArray, isConvertibleToNumber, makeApiResponse, makeService, mergeArraysByKey, objectHelper, pReduce, padZeros, printControlCharReport, replacePlaceholders, sanitizeText, shuffleArray, stringFormatter, stringHelper, tenantPlugin, trackingPlugin };
+export { ActionRecord, ApiResponse, AwsStsS3Client, keyValueObject_KeyValueObject as KeyValueObject, Metadata, PushEnvelope, QMeta, Repo, Service, Status, StatusDocument, TemplateCompiler, TenantAwareEntity, TrackedEntity, UniqueKeyGenerator, authorize, bwipJsHelper, calculateAge, changeCreatorOwner, concatStringByArray, convertString, detectControlCharacters, downloadFileByUrl, escapeRegex, expressHelper, extractEmails, formatDate, generalPost, getObjectByArr, getValidation, getValueByKeys_getValueByKeys as getValueByKeys, groupArrayByKey, init, initFromArray, initOnlyValidFromArray, isConvertibleToNumber, makeApiResponse, makeService, mergeArraysByKey, objectHelper, pMap, pMapIterable, pMapSkip, pReduce, padZeros, printControlCharReport, replacePlaceholders, sanitizeText, shuffleArray, stringFormatter, stringHelper, tenantPlugin, trackingPlugin };

package/dist/q-utilities.min.js

@@ -120,6 +120,9 @@ __webpack_require__.d(__webpack_exports__, {
   makeService: () => (/* reexport */ makeService),
   mergeArraysByKey: () => (/* reexport */ mergeArraysByKey),
   objectHelper: () => (/* reexport */ objectHelper),
+  pMap: () => (/* reexport */ pMap),
+  pMapIterable: () => (/* reexport */ pMapIterable),
+  pMapSkip: () => (/* reexport */ pMapSkip),
   pReduce: () => (/* reexport */ pReduce),
   padZeros: () => (/* reexport */ padZeros),
   printControlCharReport: () => (/* reexport */ printControlCharReport),
@@ -1380,15 +1383,19 @@ class Repo {
   }
 
   // systemLog is optional
-  findAll({ query, systemLog }) {
+  findAll({ config = {}, query, systemLog }) {
     const log = _makeLog({
       systemLog,
       label: 'REPO_READ',
       message: `fn ${this._classname}.prototype.findAll`,
       input: [{ query: { ...query }, systemLog: { ...systemLog } }]
     })
+    const queryOptions = {
+      ...this.queryOptions,
+      ...config,
+    }
     return new Promise((resolve, reject) => {
-      this.model.findAll(query, this.queryOptions, (err, data, total) => {
+      this.model.findAll(query, queryOptions, (err, data, total) => {
         if (err) {
           log({ level: 'warn', output: err.toString() })
           reject(err)
@@ -1405,15 +1412,19 @@ class Repo {
     })
   }
 
-  findOne({ query, systemLog }) {
+  findOne({ config = {}, query, systemLog }) {
     const log = _makeLog({
       systemLog,
       label: 'REPO_READ',
       message: `fn ${this._classname}.prototype.findOne`,
       input: [{ query: { ...query }, systemLog: { ...systemLog } }]
     })
+    const queryOptions = {
+      ...this.queryOptions,
+      ...config,
+    }
     return new Promise((resolve, reject) => {
-      this.model.findAll(query, this.queryOptions, (err, data) => {
+      this.model.findAll(query, queryOptions, (err, data) => {
         if (err) {
           reject(err)
         } else if (data.length === 1) {
@@ -1447,15 +1458,16 @@ class Repo {
     })
     const promise = typeof this.model.saveAll === 'function'
       ? this.model.saveAll({ config, docs })
-      : Promise.all(docs.map(async (doc) => {
-          if (doc) {
-            const result = await this.saveOne({ config, doc })
-            isNew = result.isNew
-            const _data = result._data || result.data
-            return _data[0]
-          }
-          return null
-        }))
+      : _saveAll({ config, docs, service: this })
+    // : Promise.all(docs.map(async (doc) => {
+    //     if (doc) {
+    //       const result = await this.saveOne({ config, doc })
+    //       isNew = result.isNew
+    //       const _data = result._data || result.data
+    //       return _data[0]
+    //     }
+    //     return null
+    //   }))
     return promise.then((savedData) => {
       if (savedData.length !== 1)
         isNew = null
@@ -1516,6 +1528,32 @@ function _makeLog({ systemLog, label, message: message1, input } = {}) {
   }
 }
 
+async function _saveAll({ config = {}, docs, service }) {
+  let _result = null
+  if (config.session || service.saveOptions.session) {
+    _result = await pMap(docs, async (doc) => {
+      if (doc) {
+        const result = await service.saveOne({ config, doc })
+        // isNew = result.isNew
+        const _data = result._data || result.data
+        return _data[0]
+      }
+      return null
+    }, { concurrency: 1 })
+  } else {
+    _result = await Promise.all(docs.map(async (doc) => {
+      if (doc) {
+        const result = await service.saveOne({ config, doc })
+        // isNew = result.isNew
+        const _data = result._data || result.data
+        return _data[0]
+      }
+      return null
+    }))
+  }
+  return _result
+}
+
 
 
 ;// ./lib/models/repo/index.js
@@ -1551,16 +1589,16 @@ class Service {
     //   })
   }
 
-  async findAll({ query = {}, systemLog } = {}) {
-    const result = await this.repo.findAll({ query, systemLog })
+  async findAll({ config = {}, query = {}, systemLog } = {}) {
+    const result = await this.repo.findAll({ config, query, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
     })
   }
 
-  async findOne({ query = {}, systemLog } = {}) {
-    const result = await this.repo.findOne({ query, systemLog })
+  async findOne({ config = {}, query = {}, systemLog } = {}) {
+    const result = await this.repo.findOne({ config, query, systemLog })
     return makeApiResponse({
       repo: this.repo,
       result
@@ -3930,6 +3968,293 @@ function padZeros(num, minLength = 6) {
 
 
 
+;// ./lib/helpers/pMap/pMap.js
+async function pMap(
+  iterable,
+  mapper,
+  {
+    concurrency = Number.POSITIVE_INFINITY,
+    stopOnError = true,
+    signal,
+  } = {},
+) {
+  return new Promise((resolve_, reject_) => {
+    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`)
+    }
+
+    if (typeof mapper !== 'function') {
+      throw new TypeError('Mapper function is required')
+    }
+
+    if (!((Number.isSafeInteger(concurrency) && concurrency >= 1) || concurrency === Number.POSITIVE_INFINITY)) {
+      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`)
+    }
+
+    const result = []
+    const errors = []
+    const skippedIndexesMap = new Map()
+    let isRejected = false
+    let isResolved = false
+    let isIterableDone = false
+    let resolvingCount = 0
+    let currentIndex = 0
+    const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]()
+
+    const signalListener = () => {
+      reject(signal.reason)
+    }
+
+    const cleanup = () => {
+      signal?.removeEventListener('abort', signalListener)
+    }
+
+    const resolve = (value) => {
+      resolve_(value)
+      cleanup()
+    }
+
+    const reject = (reason) => {
+      isRejected = true
+      isResolved = true
+      reject_(reason)
+      cleanup()
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(signal.reason)
+      }
+
+      signal.addEventListener('abort', signalListener, { once: true })
+    }
+
+    const next = async () => {
+      if (isResolved) {
+        return
+      }
+
+      const nextItem = await iterator.next()
+
+      const index = currentIndex
+      currentIndex++
+
+      // Note: `iterator.next()` can be called many times in parallel.
+      // This can cause multiple calls to this `next()` function to
+      // receive a `nextItem` with `done === true`.
+      // The shutdown logic that rejects/resolves must be protected
+      // so it runs only one time as the `skippedIndex` logic is
+      // non-idempotent.
+      if (nextItem.done) {
+        isIterableDone = true
+
+        if (resolvingCount === 0 && !isResolved) {
+          if (!stopOnError && errors.length > 0) {
+            reject(new AggregateError(errors)) // eslint-disable-line unicorn/error-message
+            return
+          }
+
+          isResolved = true
+
+          if (skippedIndexesMap.size === 0) {
+            resolve(result)
+            return
+          }
+
+          const pureResult = []
+
+          // Support multiple `pMapSkip`'s.
+          for (const [index, value] of result.entries()) {
+            if (skippedIndexesMap.get(index) === pMapSkip) {
+              continue
+            }
+
+            pureResult.push(value)
+          }
+
+          resolve(pureResult)
+        }
+
+        return
+      }
+
+      resolvingCount++;
+
+      // Intentionally detached
+      (async () => {
+        try {
+          const element = await nextItem.value
+
+          if (isResolved) {
+            return
+          }
+
+          const value = await mapper(element, index)
+
+          // Use Map to stage the index of the element.
+          if (value === pMapSkip) {
+            skippedIndexesMap.set(index, value)
+          }
+
+          result[index] = value
+
+          resolvingCount--
+          await next()
+        } catch (error) {
+          if (stopOnError) {
+            reject(error)
+          } else {
+            errors.push(error)
+            resolvingCount--
+
+            // In that case we can't really continue regardless of `stopOnError` state
+            // since an iterable is likely to continue throwing after it throws once.
+            // If we continue calling `next()` indefinitely we will likely end up
+            // in an infinite loop of failed iteration.
+            try {
+              await next()
+            } catch (error) {
+              reject(error)
+            }
+          }
+        }
+      })()
+    };
+
+    // Create the concurrent runners in a detached (non-awaited)
+    // promise. We need this so we can await the `next()` calls
+    // to stop creating runners before hitting the concurrency limit
+    // if the iterable has already been marked as done.
+    // NOTE: We *must* do this for async iterators otherwise we'll spin up
+    // infinite `next()` calls by default and never start the event loop.
+    (async () => {
+      for (let index = 0; index < concurrency; index++) {
+        try {
+          await next()
+        } catch (error) {
+          reject(error)
+          break
+        }
+
+        if (isIterableDone || isRejected) {
+          break
+        }
+      }
+    })()
+  })
+}
+
+function pMapIterable(
+  iterable,
+  mapper,
+  {
+    concurrency = Number.POSITIVE_INFINITY,
+    backpressure = concurrency,
+  } = {},
+) {
+  if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+    throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`)
+  }
+
+  if (typeof mapper !== 'function') {
+    throw new TypeError('Mapper function is required')
+  }
+
+  if (!((Number.isSafeInteger(concurrency) && concurrency >= 1) || concurrency === Number.POSITIVE_INFINITY)) {
+    throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`)
+  }
+
+  if (!((Number.isSafeInteger(backpressure) && backpressure >= concurrency) || backpressure === Number.POSITIVE_INFINITY)) {
+    throw new TypeError(`Expected \`backpressure\` to be an integer from \`concurrency\` (${concurrency}) and up or \`Infinity\`, got \`${backpressure}\` (${typeof backpressure})`)
+  }
+
+  return {
+    async* [Symbol.asyncIterator]() {
+      const iterator = iterable[Symbol.asyncIterator] === undefined ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]()
+
+      const promises = []
+      let pendingPromisesCount = 0
+      let isDone = false
+      let index = 0
+
+      function trySpawn() {
+        if (isDone || !(pendingPromisesCount < concurrency && promises.length < backpressure)) {
+          return
+        }
+
+        pendingPromisesCount++
+
+        const promise = (async () => {
+          const { done, value } = await iterator.next()
+
+          if (done) {
+            pendingPromisesCount--
+            return { done: true }
+          }
+
+          // Spawn if still below concurrency and backpressure limit
+          trySpawn()
+
+          try {
+            const returnValue = await mapper(await value, index++)
+
+            pendingPromisesCount--
+
+            if (returnValue === pMapSkip) {
+              const index = promises.indexOf(promise)
+
+              if (index > 0) {
+                promises.splice(index, 1)
+              }
+            }
+
+            // Spawn if still below backpressure limit and just dropped below concurrency limit
+            trySpawn()
+
+            return { done: false, value: returnValue }
+          } catch (error) {
+            pendingPromisesCount--
+            isDone = true
+            return { error }
+          }
+        })()
+
+        promises.push(promise)
+      }
+
+      trySpawn()
+
+      while (promises.length > 0) {
+        const { error, done, value } = await promises[0]
+
+        promises.shift()
+
+        if (error) {
+          throw error
+        }
+
+        if (done) {
+          return
+        }
+
+        // Spawn if just dropped below backpressure limit and below the concurrency limit
+        trySpawn()
+
+        if (value === pMapSkip) {
+          continue
+        }
+
+        yield value
+      }
+    },
+  }
+}
+
+const pMapSkip = Symbol('skip')
+
+;// ./lib/helpers/pMap/index.js
+
+
 ;// ./lib/helpers/pReduce/index.js
 
 
@@ -4286,11 +4611,19 @@ function toLowerCase(str) {
     .toLowerCase()
 }
 
+function toScreamingSnakeCase(str) {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    .toUpperCase()
+}
+
 const stringHelper = {
   isSame,
   setCode,
   toCamelCase,
   toLowerCase,
+  toScreamingSnakeCase,
 }
 
 
@@ -4426,6 +4759,7 @@ function tenantPlugin(schema, options) {
 
 
 
+
 
 
 ;// ./lib/index.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@questwork/q-utilities",
-  "version": "0.1.24",
+  "version": "0.1.30",
   "description": "Questwork QUtilities",
   "author": {
     "name": "Questwork Consulting Limited",
@@ -31,6 +31,7 @@
     "@aws-sdk/client-sts": "^3.812.0",
     "@babel/core": "^7.27.1",
     "@babel/eslint-parser": "^7.27.1",
+    "@jmespath-community/jmespath": "^1.3.0",
     "@questwork/q-eslint-config": "^0.1.8",
     "babel-loader": "^8.2.4",
     "babel-plugin-component": "^1.1.1",