@naturalcycles/js-lib 14.79.0 → 14.82.0

package/dist-esm/promise/pMap.js

@@ -6,6 +6,7 @@ Improvements:
 - Included Typescript typings (no need for @types/p-map)
 - Compatible with pProps (that had typings issues)
  */
+import { __asyncValues } from "tslib";
 import { END, ErrorMode, SKIP } from '..';
 import { AggregatedError } from './AggregatedError';
 /**
@@ -35,28 +36,85 @@ import { AggregatedError } from './AggregatedError';
  * })();
  */
 export async function pMap(iterable, mapper, opt = {}) {
+    var e_1, _a;
+    const ret = [];
+    // const iterator = iterable[Symbol.iterator]()
+    const items = [...iterable];
+    const itemsLength = items.length;
+    if (itemsLength === 0)
+        return []; // short circuit
+    const { concurrency = itemsLength, errorMode = ErrorMode.THROW_IMMEDIATELY } = opt;
+    const errors = [];
+    let isSettled = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
+    // Special cases that are able to preserve async stack traces
+    if (concurrency === 1) {
+        try {
+            // Special case for concurrency == 1
+            for (var items_1 = __asyncValues(items), items_1_1; items_1_1 = await items_1.next(), !items_1_1.done;) {
+                const item = items_1_1.value;
+                try {
+                    const r = await mapper(item, currentIndex++);
+                    if (r === END)
+                        break;
+                    if (r !== SKIP)
+                        ret.push(r);
+                }
+                catch (err) {
+                    if (errorMode === ErrorMode.THROW_IMMEDIATELY)
+                        throw err;
+                    if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                        errors.push(err);
+                    }
+                    // otherwise, suppress completely
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) await _a.call(items_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (errors.length) {
+            throw new AggregatedError(errors, ret);
+        }
+        return ret;
+    }
+    else if (!opt.concurrency || items.length <= opt.concurrency) {
+        // Special case for concurrency == infinity or iterable.length < concurrency
+        if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
+            return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== SKIP && r !== END);
+        }
+        ;
+        (await Promise.allSettled(items.map((item, i) => mapper(item, i)))).forEach(r => {
+            if (r.status === 'fulfilled') {
+                if (r.value !== SKIP && r.value !== END)
+                    ret.push(r.value);
+            }
+            else if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                errors.push(r.reason);
+            }
+        });
+        if (errors.length) {
+            throw new AggregatedError(errors, ret);
+        }
+        return ret;
+    }
     return new Promise((resolve, reject) => {
-        const { concurrency = Number.POSITIVE_INFINITY, errorMode = ErrorMode.THROW_IMMEDIATELY } = opt;
-        const ret = [];
-        const iterator = iterable[Symbol.iterator]();
-        const errors = [];
-        let isSettled = false;
-        let isIterableDone = false;
-        let resolvingCount = 0;
-        let currentIndex = 0;
-        const next = (skipped = false) => {
+        const next = () => {
             if (isSettled) {
                 return;
             }
-            const nextItem = iterator.next();
-            const i = currentIndex;
-            if (!skipped)
-                currentIndex++;
-            if (nextItem.done) {
-                isIterableDone = true;
+            const nextItem = items[currentIndex];
+            const i = currentIndex++;
+            if (currentIndex > itemsLength) {
                 if (resolvingCount === 0) {
+                    isSettled = true;
                     const r = ret.filter(r => r !== SKIP);
-                    if (errors.length && errorMode === ErrorMode.THROW_AGGREGATED) {
+                    if (errors.length) {
                         reject(new AggregatedError(errors, r));
                     }
                     else {
@@ -66,7 +124,7 @@ export async function pMap(iterable, mapper, opt = {}) {
                 return;
             }
             resolvingCount++;
-            Promise.resolve(nextItem.value)
+            Promise.resolve(nextItem)
                 .then(async (element) => await mapper(element, i))
                 .then(value => {
                 if (value === END) {
@@ -82,7 +140,9 @@ export async function pMap(iterable, mapper, opt = {}) {
                     reject(err);
                 }
                 else {
-                    errors.push(err);
+                    if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                        errors.push(err);
+                    }
                     resolvingCount--;
                     next();
                 }
@@ -90,7 +150,7 @@ export async function pMap(iterable, mapper, opt = {}) {
         };
         for (let i = 0; i < concurrency; i++) {
             next();
-            if (isIterableDone) {
+            if (isSettled) {
                 break;
             }
         }

package/dist-esm/promise/pRetry.js

@@ -1,54 +1,85 @@
 import { _since, _stringifyAny } from '..';
+import { TimeoutError } from './pTimeout';
 /**
  * Returns a Function (!), enhanced with retry capabilities.
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function pRetry(fn, opt = {}) {
-    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name = fn.name, } = opt;
+export function pRetryFn(fn, opt = {}) {
+    return async function pRetryFunction(...args) {
+        return await pRetry(() => fn.call(this, ...args), opt);
+    };
+}
+export async function pRetry(fn, opt = {}) {
+    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name, keepStackTrace = true, timeout, } = opt;
+    const fakeError = keepStackTrace ? new Error('RetryError') : undefined;
     let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt;
     if (opt.logAll) {
-        logFirstAttempt = logRetries = logFailures = true;
+        logSuccess = logFirstAttempt = logRetries = logFailures = true;
     }
     if (opt.logNone) {
         logSuccess = logFirstAttempt = logRetries = logFailures = false;
     }
-    const fname = ['pRetry', name].filter(Boolean).join('.');
-    return async function (...args) {
-        let delay = initialDelay;
-        let attempt = 0;
-        return await new Promise((resolve, reject) => {
-            const next = async () => {
-                const started = Date.now();
-                try {
-                    attempt++;
-                    if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
-                        logger.log(`${fname} attempt #${attempt}...`);
-                    }
-                    const r = await fn.apply(this, args);
-                    if (logSuccess) {
-                        logger.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`);
-                    }
-                    resolve(r);
+    const fname = name || fn.name || 'pRetry function';
+    let delay = initialDelay;
+    let attempt = 0;
+    let timer;
+    let timedOut = false;
+    return await new Promise((resolve, reject) => {
+        const rejectWithTimeout = () => {
+            timedOut = true; // to prevent more tries
+            const err = new TimeoutError(`"${fname}" timed out after ${timeout} ms`);
+            if (fakeError) {
+                // keep original stack
+                err.stack = fakeError.stack.replace('Error: RetryError', 'TimeoutError');
+            }
+            reject(err);
+        };
+        const next = async () => {
+            if (timedOut)
+                return;
+            if (timeout) {
+                timer = setTimeout(rejectWithTimeout, timeout);
+            }
+            const started = Date.now();
+            try {
+                attempt++;
+                if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
+                    logger.log(`${fname} attempt #${attempt}...`);
                 }
-                catch (err) {
-                    if (logFailures) {
-                        logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, _stringifyAny(err, {
-                            includeErrorData: true,
-                        }));
-                    }
-                    if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
-                        // Give up
-                        reject(err);
-                    }
-                    else {
-                        // Retry after delay
-                        delay *= delayMultiplier;
-                        setTimeout(next, delay);
+                const r = await fn(attempt);
+                clearTimeout(timer);
+                if (logSuccess) {
+                    logger.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`);
+                }
+                resolve(r);
+            }
+            catch (err) {
+                clearTimeout(timer);
+                if (logFailures) {
+                    logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, _stringifyAny(err, {
+                        includeErrorData: true,
+                    }));
+                }
+                if (attempt >= maxAttempts ||
+                    (predicate && !predicate(err, attempt, maxAttempts))) {
+                    // Give up
+                    if (fakeError) {
+                        // Preserve the original call stack
+                        Object.defineProperty(err, 'stack', {
+                            value: err.stack +
+                                '\n    --' +
+                                fakeError.stack.replace('Error: RetryError', ''),
+                        });
                     }
+                    reject(err);
                 }
-            };
-            void next();
-        });
-    };
+                else {
+                    // Retry after delay
+                    delay *= delayMultiplier;
+                    setTimeout(next, delay);
+                }
+            }
+        };
+        void next();
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.79.0",
+  "version": "14.82.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/decorators/retry.decorator.ts

@@ -1,10 +1,10 @@
-import { pRetry, PRetryOptions } from '..'
+import { pRetryFn, PRetryOptions } from '..'
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export function _Retry(opt: PRetryOptions = {}): MethodDecorator {
   return (target, key, descriptor) => {
     const originalFn = descriptor.value
-    descriptor.value = pRetry(originalFn as any, opt)
+    descriptor.value = pRetryFn(originalFn as any, opt)
     return descriptor
   }
 }

package/src/index.ts

@@ -67,14 +67,13 @@ export * from './object/object.util'
 export * from './object/sortObject'
 export * from './object/sortObjectDeep'
 import { AggregatedError } from './promise/AggregatedError'
-export * from './promise/pBatch'
 import { DeferredPromise, pDefer } from './promise/pDefer'
 export * from './promise/pDelay'
 export * from './promise/pFilter'
 export * from './promise/pHang'
 import { pMap, PMapOptions } from './promise/pMap'
 export * from './promise/pProps'
-import { pRetry, PRetryOptions } from './promise/pRetry'
+import { pRetry, pRetryFn, PRetryOptions } from './promise/pRetry'
 export * from './promise/pState'
 import { pTimeout, pTimeoutFn, PTimeoutOptions } from './promise/pTimeout'
 export * from './promise/pTuple'
@@ -250,6 +249,7 @@ export {
   pDefer,
   AggregatedError,
   pRetry,
+  pRetryFn,
   pTimeout,
   pTimeoutFn,
   _tryCatch,

package/src/json-schema/jsonSchemaBuilder.ts

@@ -365,9 +365,9 @@ export class JsonSchemaObjectBuilder<T extends AnyObject> extends JsonSchemaAnyB
     return this
   }
 
-  baseDBEntity(): JsonSchemaObjectBuilder<T & BaseDBEntity> {
+  baseDBEntity<ID = string>(idType = 'string'): JsonSchemaObjectBuilder<T & BaseDBEntity<ID>> {
     Object.assign(this.schema.properties, {
-      id: { type: 'string' },
+      id: { type: idType },
       created: { type: 'number', format: 'unixTimestamp' },
       updated: { type: 'number', format: 'unixTimestamp' },
     })
@@ -375,8 +375,8 @@ export class JsonSchemaObjectBuilder<T extends AnyObject> extends JsonSchemaAnyB
     return this
   }
 
-  savedDBEntity(): JsonSchemaObjectBuilder<T & SavedDBEntity> {
-    return this.baseDBEntity().addRequired(['id', 'created', 'updated']) as any
+  savedDBEntity<ID = string>(idType = 'string'): JsonSchemaObjectBuilder<T & SavedDBEntity<ID>> {
+    return this.baseDBEntity(idType).addRequired(['id', 'created', 'updated']) as any
   }
 
   extend<T2 extends AnyObject>(s2: JsonSchemaObjectBuilder<T2>): JsonSchemaObjectBuilder<T & T2> {

package/src/promise/AggregatedError.ts

@@ -7,20 +7,15 @@ export class AggregatedError<RESULT = any> extends Error {
   errors!: Error[]
   results!: RESULT[]
 
-  constructor(errors: (Error | string)[], results: RESULT[] = []) {
-    const mappedErrors = errors.map(e => {
-      if (typeof e === 'string') return new Error(e)
-      return e
-    })
-
+  constructor(errors: Error[], results: RESULT[] = []) {
     const message = [
       `${errors.length} errors:`,
-      ...mappedErrors.map((e, i) => `${i + 1}. ${e.message}`),
+      ...errors.map((e, i) => `${i + 1}. ${e.message}`),
     ].join('\n')
 
     super(message)
 
-    this.errors = mappedErrors
+    this.errors = errors
     this.results = results
 
     Object.defineProperty(this, 'name', {

package/src/promise/pFilter.ts

@@ -1,16 +1,7 @@
-import { AbortableAsyncPredicate } from '../types'
-import { pMap, PMapOptions } from './pMap'
+import { AsyncPredicate } from '../types'
 
-export async function pFilter<T>(
-  iterable: Iterable<T | PromiseLike<T>>,
-  filterFn: AbortableAsyncPredicate<T>,
-  opt?: PMapOptions,
-): Promise<T[]> {
-  const values = await pMap(
-    iterable,
-    async (item, index) => await Promise.all([filterFn(item, index), item]),
-    opt,
-  )
-
-  return values.filter(value => Boolean(value[0])).map(value => value[1])
+export async function pFilter<T>(iterable: Iterable<T>, filterFn: AsyncPredicate<T>): Promise<T[]> {
+  const items = [...iterable]
+  const predicates = await Promise.all(items.map((item, i) => filterFn(item, i)))
+  return items.filter((item, i) => predicates[i])
 }

package/src/promise/pMap.ts

@@ -55,36 +55,85 @@ export interface PMapOptions {
  * })();
  */
 export async function pMap<IN, OUT>(
-  iterable: Iterable<IN | PromiseLike<IN>>,
+  iterable: Iterable<IN>,
   mapper: AbortableAsyncMapper<IN, OUT>,
   opt: PMapOptions = {},
 ): Promise<OUT[]> {
-  return new Promise<OUT[]>((resolve, reject) => {
-    const { concurrency = Number.POSITIVE_INFINITY, errorMode = ErrorMode.THROW_IMMEDIATELY } = opt
+  const ret: (OUT | typeof SKIP)[] = []
+  // const iterator = iterable[Symbol.iterator]()
+  const items = [...iterable]
+  const itemsLength = items.length
+  if (itemsLength === 0) return [] // short circuit
+
+  const { concurrency = itemsLength, errorMode = ErrorMode.THROW_IMMEDIATELY } = opt
+
+  const errors: Error[] = []
+  let isSettled = false
+  let resolvingCount = 0
+  let currentIndex = 0
+
+  // Special cases that are able to preserve async stack traces
+
+  if (concurrency === 1) {
+    // Special case for concurrency == 1
+
+    for await (const item of items) {
+      try {
+        const r = await mapper(item, currentIndex++)
+        if (r === END) break
+        if (r !== SKIP) ret.push(r)
+      } catch (err) {
+        if (errorMode === ErrorMode.THROW_IMMEDIATELY) throw err
+        if (errorMode === ErrorMode.THROW_AGGREGATED) {
+          errors.push(err as Error)
+        }
+        // otherwise, suppress completely
+      }
+    }
+
+    if (errors.length) {
+      throw new AggregatedError(errors, ret)
+    }
+
+    return ret as OUT[]
+  } else if (!opt.concurrency || items.length <= opt.concurrency) {
+    // Special case for concurrency == infinity or iterable.length < concurrency
+
+    if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
+      return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(
+        r => r !== SKIP && r !== END,
+      ) as OUT[]
+    }
+
+    ;(await Promise.allSettled(items.map((item, i) => mapper(item, i)))).forEach(r => {
+      if (r.status === 'fulfilled') {
+        if (r.value !== SKIP && r.value !== END) ret.push(r.value)
+      } else if (errorMode === ErrorMode.THROW_AGGREGATED) {
+        errors.push(r.reason)
+      }
+    })
+
+    if (errors.length) {
+      throw new AggregatedError(errors, ret)
+    }
 
-    const ret: (OUT | typeof SKIP)[] = []
-    const iterator = iterable[Symbol.iterator]()
-    const errors: Error[] = []
-    let isSettled = false
-    let isIterableDone = false
-    let resolvingCount = 0
-    let currentIndex = 0
+    return ret as OUT[]
+  }
 
-    const next = (skipped = false) => {
+  return new Promise<OUT[]>((resolve, reject) => {
+    const next = () => {
       if (isSettled) {
         return
       }
 
-      const nextItem = iterator.next()
-      const i = currentIndex
-      if (!skipped) currentIndex++
-
-      if (nextItem.done) {
-        isIterableDone = true
+      const nextItem = items[currentIndex]!
+      const i = currentIndex++
 
+      if (currentIndex > itemsLength) {
         if (resolvingCount === 0) {
+          isSettled = true
           const r = ret.filter(r => r !== SKIP) as OUT[]
-          if (errors.length && errorMode === ErrorMode.THROW_AGGREGATED) {
+          if (errors.length) {
             reject(new AggregatedError(errors, r))
           } else {
             resolve(r)
@@ -96,7 +145,7 @@ export async function pMap<IN, OUT>(
 
       resolvingCount++
 
-      Promise.resolve(nextItem.value)
+      Promise.resolve(nextItem)
         .then(async element => await mapper(element, i))
         .then(
           value => {
@@ -114,7 +163,9 @@ export async function pMap<IN, OUT>(
               isSettled = true
               reject(err)
             } else {
-              errors.push(err)
+              if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                errors.push(err)
+              }
               resolvingCount--
               next()
             }
@@ -125,7 +176,7 @@ export async function pMap<IN, OUT>(
     for (let i = 0; i < concurrency; i++) {
       next()
 
-      if (isIterableDone) {
+      if (isSettled) {
         break
       }
     }