@naturalcycles/js-lib 14.79.0 → 14.82.0

package/dist/decorators/retry.decorator.js

@@ -6,7 +6,7 @@ const __1 = require("..");
 function _Retry(opt = {}) {
     return (target, key, descriptor) => {
         const originalFn = descriptor.value;
-        descriptor.value = (0, __1.pRetry)(originalFn, opt);
+        descriptor.value = (0, __1.pRetryFn)(originalFn, opt);
         return descriptor;
     };
 }

package/dist/index.d.ts

@@ -34,14 +34,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';
@@ -60,4 +59,4 @@ import { PQueue, PQueueCfg } from './promise/pQueue';
 export * from './seq/seq';
 export * from './math/stack.util';
 export type { AbortableMapper, AbortablePredicate, AbortableAsyncPredicate, AbortableAsyncMapper, PQueueCfg, MemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateTime, Reviver, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestamp, BaseDBEntity, SavedDBEntity, Saved, Unsaved, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
-export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };
+export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pRetryFn, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SKIP = exports.END = exports.PQueue = exports.commonLoggerCreate = exports.commonLoggerPrefix = exports.commonLoggerPipe = exports.commonLogLevelNumber = exports.commonLoggerNoop = exports.commonLoggerMinLevel = exports.JsonSchemaAnyBuilder = exports.jsonSchema = exports._stringifyAny = exports._TryCatch = exports._tryCatch = exports.pTimeoutFn = exports.pTimeout = exports.pRetry = exports.AggregatedError = exports.pDefer = exports.ErrorMode = exports._noop = exports._passNothingPredicate = exports._passthroughPredicate = exports._passUndefinedMapper = exports._passthroughMapper = exports.pMap = exports._objectKeys = exports._stringMapEntries = exports._stringMapValues = exports._createPromiseDecorator = exports.is = void 0;
+exports.SKIP = exports.END = exports.PQueue = exports.commonLoggerCreate = exports.commonLoggerPrefix = exports.commonLoggerPipe = exports.commonLogLevelNumber = exports.commonLoggerNoop = exports.commonLoggerMinLevel = exports.JsonSchemaAnyBuilder = exports.jsonSchema = exports._stringifyAny = exports._TryCatch = exports._tryCatch = exports.pTimeoutFn = exports.pTimeout = exports.pRetryFn = exports.pRetry = exports.AggregatedError = exports.pDefer = exports.ErrorMode = exports._noop = exports._passNothingPredicate = exports._passthroughPredicate = exports._passUndefinedMapper = exports._passthroughMapper = exports.pMap = exports._objectKeys = exports._stringMapEntries = exports._stringMapValues = exports._createPromiseDecorator = exports.is = void 0;
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./array/array.util"), exports);
 (0, tslib_1.__exportStar)(require("./lazy"), exports);
@@ -42,7 +42,6 @@ Object.defineProperty(exports, "JsonSchemaAnyBuilder", { enumerable: true, get:
 (0, tslib_1.__exportStar)(require("./object/sortObjectDeep"), exports);
 const AggregatedError_1 = require("./promise/AggregatedError");
 Object.defineProperty(exports, "AggregatedError", { enumerable: true, get: function () { return AggregatedError_1.AggregatedError; } });
-(0, tslib_1.__exportStar)(require("./promise/pBatch"), exports);
 const pDefer_1 = require("./promise/pDefer");
 Object.defineProperty(exports, "pDefer", { enumerable: true, get: function () { return pDefer_1.pDefer; } });
 (0, tslib_1.__exportStar)(require("./promise/pDelay"), exports);
@@ -53,6 +52,7 @@ Object.defineProperty(exports, "pMap", { enumerable: true, get: function () { re
 (0, tslib_1.__exportStar)(require("./promise/pProps"), exports);
 const pRetry_1 = require("./promise/pRetry");
 Object.defineProperty(exports, "pRetry", { enumerable: true, get: function () { return pRetry_1.pRetry; } });
+Object.defineProperty(exports, "pRetryFn", { enumerable: true, get: function () { return pRetry_1.pRetryFn; } });
 (0, tslib_1.__exportStar)(require("./promise/pState"), exports);
 const pTimeout_1 = require("./promise/pTimeout");
 Object.defineProperty(exports, "pTimeout", { enumerable: true, get: function () { return pTimeout_1.pTimeout; } });

package/dist/json-schema/jsonSchemaBuilder.d.ts

@@ -113,8 +113,8 @@ export declare class JsonSchemaObjectBuilder<T extends AnyObject> extends JsonSc
     minProps(minProperties: number): this;
     maxProps(maxProperties: number): this;
     additionalProps(additionalProperties: boolean): this;
-    baseDBEntity(): JsonSchemaObjectBuilder<T & BaseDBEntity>;
-    savedDBEntity(): JsonSchemaObjectBuilder<T & SavedDBEntity>;
+    baseDBEntity<ID = string>(idType?: string): JsonSchemaObjectBuilder<T & BaseDBEntity<ID>>;
+    savedDBEntity<ID = string>(idType?: string): JsonSchemaObjectBuilder<T & SavedDBEntity<ID>>;
     extend<T2 extends AnyObject>(s2: JsonSchemaObjectBuilder<T2>): JsonSchemaObjectBuilder<T & T2>;
 }
 export declare class JsonSchemaArrayBuilder<ITEM> extends JsonSchemaAnyBuilder<ITEM[], JsonSchemaArray<ITEM>> {

package/dist/json-schema/jsonSchemaBuilder.js

@@ -306,16 +306,16 @@ class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
         Object.assign(this.schema, { additionalProperties });
         return this;
     }
-    baseDBEntity() {
+    baseDBEntity(idType = 'string') {
         Object.assign(this.schema.properties, {
-            id: { type: 'string' },
+            id: { type: idType },
             created: { type: 'number', format: 'unixTimestamp' },
             updated: { type: 'number', format: 'unixTimestamp' },
         });
         return this;
     }
-    savedDBEntity() {
-        return this.baseDBEntity().addRequired(['id', 'created', 'updated']);
+    savedDBEntity(idType = 'string') {
+        return this.baseDBEntity(idType).addRequired(['id', 'created', 'updated']);
     }
     extend(s2) {
         const builder = new JsonSchemaObjectBuilder();

package/dist/json-schema/jsonSchemas.d.ts

@@ -1,3 +1,3 @@
 import { SavedDBEntity } from '../types';
-export declare const baseDBEntityJsonSchema: import("./jsonSchemaBuilder").JsonSchemaObjectBuilder<Partial<SavedDBEntity>>;
-export declare const savedDBEntityJsonSchema: import("./jsonSchemaBuilder").JsonSchemaObjectBuilder<SavedDBEntity>;
+export declare const baseDBEntityJsonSchema: import("./jsonSchemaBuilder").JsonSchemaObjectBuilder<Partial<SavedDBEntity<string>>>;
+export declare const savedDBEntityJsonSchema: import("./jsonSchemaBuilder").JsonSchemaObjectBuilder<SavedDBEntity<string>>;

package/dist/promise/AggregatedError.d.ts

@@ -6,5 +6,5 @@
 export declare class AggregatedError<RESULT = any> extends Error {
     errors: Error[];
     results: RESULT[];
-    constructor(errors: (Error | string)[], results?: RESULT[]);
+    constructor(errors: Error[], results?: RESULT[]);
 }

package/dist/promise/AggregatedError.js

@@ -8,17 +8,12 @@ exports.AggregatedError = void 0;
  */
 class AggregatedError extends Error {
     constructor(errors, results = []) {
-        const mappedErrors = errors.map(e => {
-            if (typeof e === 'string')
-                return new Error(e);
-            return e;
-        });
         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', {
             value: this.constructor.name,

package/dist/promise/pFilter.d.ts

@@ -1,3 +1,2 @@
-import { AbortableAsyncPredicate } from '../types';
-import { PMapOptions } from './pMap';
-export declare function pFilter<T>(iterable: Iterable<T | PromiseLike<T>>, filterFn: AbortableAsyncPredicate<T>, opt?: PMapOptions): Promise<T[]>;
+import { AsyncPredicate } from '../types';
+export declare function pFilter<T>(iterable: Iterable<T>, filterFn: AsyncPredicate<T>): Promise<T[]>;

package/dist/promise/pFilter.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pFilter = void 0;
-const pMap_1 = require("./pMap");
-async function pFilter(iterable, filterFn, opt) {
-    const values = await (0, pMap_1.pMap)(iterable, async (item, index) => await Promise.all([filterFn(item, index), item]), opt);
-    return values.filter(value => Boolean(value[0])).map(value => value[1]);
+async function pFilter(iterable, filterFn) {
+    const items = [...iterable];
+    const predicates = await Promise.all(items.map((item, i) => filterFn(item, i)));
+    return items.filter((item, i) => predicates[i]);
 }
 exports.pFilter = pFilter;

package/dist/promise/pMap.d.ts

@@ -41,4 +41,4 @@ export interface PMapOptions {
  * 	//=> ['http://ava.li/', 'http://todomvc.com/']
  * })();
  */
-export declare function pMap<IN, OUT>(iterable: Iterable<IN | PromiseLike<IN>>, mapper: AbortableAsyncMapper<IN, OUT>, opt?: PMapOptions): Promise<OUT[]>;
+export declare function pMap<IN, OUT>(iterable: Iterable<IN>, mapper: AbortableAsyncMapper<IN, OUT>, opt?: PMapOptions): Promise<OUT[]>;

package/dist/promise/pMap.js

@@ -38,28 +38,74 @@ const AggregatedError_1 = require("./AggregatedError");
  * })();
  */
 async function pMap(iterable, mapper, opt = {}) {
+    const ret = [];
+    // const iterator = iterable[Symbol.iterator]()
+    const items = [...iterable];
+    const itemsLength = items.length;
+    if (itemsLength === 0)
+        return []; // short circuit
+    const { concurrency = itemsLength, errorMode = __1.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) {
+        // Special case for concurrency == 1
+        for await (const item of items) {
+            try {
+                const r = await mapper(item, currentIndex++);
+                if (r === __1.END)
+                    break;
+                if (r !== __1.SKIP)
+                    ret.push(r);
+            }
+            catch (err) {
+                if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY)
+                    throw err;
+                if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                    errors.push(err);
+                }
+                // otherwise, suppress completely
+            }
+        }
+        if (errors.length) {
+            throw new AggregatedError_1.AggregatedError(errors, ret);
+        }
+        return ret;
+    }
+    else if (!opt.concurrency || items.length <= opt.concurrency) {
+        // Special case for concurrency == infinity or iterable.length < concurrency
+        if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY) {
+            return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== __1.SKIP && r !== __1.END);
+        }
+        ;
+        (await Promise.allSettled(items.map((item, i) => mapper(item, i)))).forEach(r => {
+            if (r.status === 'fulfilled') {
+                if (r.value !== __1.SKIP && r.value !== __1.END)
+                    ret.push(r.value);
+            }
+            else if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                errors.push(r.reason);
+            }
+        });
+        if (errors.length) {
+            throw new AggregatedError_1.AggregatedError(errors, ret);
+        }
+        return ret;
+    }
     return new Promise((resolve, reject) => {
-        const { concurrency = Number.POSITIVE_INFINITY, errorMode = __1.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 !== __1.SKIP);
-                    if (errors.length && errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                    if (errors.length) {
                         reject(new AggregatedError_1.AggregatedError(errors, r));
                     }
                     else {
@@ -69,7 +115,7 @@ 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 === __1.END) {
@@ -85,7 +131,9 @@ async function pMap(iterable, mapper, opt = {}) {
                     reject(err);
                 }
                 else {
-                    errors.push(err);
+                    if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                        errors.push(err);
+                    }
                     resolvingCount--;
                     next();
                 }
@@ -93,7 +141,7 @@ async function pMap(iterable, mapper, opt = {}) {
         };
         for (let i = 0; i < concurrency; i++) {
             next();
-            if (isIterableDone) {
+            if (isSettled) {
                 break;
             }
         }

package/dist/promise/pRetry.d.ts

@@ -5,6 +5,12 @@ export interface PRetryOptions {
      * Can be used to identify the place in the code that failed.
      */
     name?: string;
+    /**
+     * Timeout for each Try, in milliseconds.
+     *
+     * Defaults to no timeout.
+     */
+    timeout?: number;
     /**
      * How many attempts to try.
      * First attempt is not a retry, but "initial try". It still counts.
@@ -29,7 +35,7 @@ export interface PRetryOptions {
      *
      * @default () => true
      */
-    predicate?: (err: unknown, attempt: number, maxAttempts: number) => boolean;
+    predicate?: (err: Error, attempt: number, maxAttempts: number) => boolean;
     /**
      * Log the first attempt (which is not a "retry" yet).
      *
@@ -62,9 +68,18 @@ export interface PRetryOptions {
      * Default to `console`
      */
     logger?: CommonLogger;
+    /**
+     * Defaults to true.
+     * If true - preserves the stack trace in case of a Timeout (usually - very useful!).
+     * It has a certain perf cost.
+     *
+     * @experimental
+     */
+    keepStackTrace?: boolean;
 }
 /**
  * Returns a Function (!), enhanced with retry capabilities.
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
  */
-export declare function pRetry<T extends AnyFunction>(fn: T, opt?: PRetryOptions): T;
+export declare function pRetryFn<T extends AnyFunction>(fn: T, opt?: PRetryOptions): T;
+export declare function pRetry<T>(fn: (attempt: number) => Promise<T>, opt?: PRetryOptions): Promise<T>;

package/dist/promise/pRetry.js

@@ -1,58 +1,90 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pRetry = void 0;
+exports.pRetry = exports.pRetryFn = void 0;
 const __1 = require("..");
+const pTimeout_1 = require("./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
-function pRetry(fn, opt = {}) {
-    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name = fn.name, } = opt;
+function pRetryFn(fn, opt = {}) {
+    return async function pRetryFunction(...args) {
+        return await pRetry(() => fn.call(this, ...args), opt);
+    };
+}
+exports.pRetryFn = pRetryFn;
+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 ${(0, __1._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 pTimeout_1.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 ${(0, __1._since)(started)}:`, (0, __1._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 ${(0, __1._since)(started)}`);
+                }
+                resolve(r);
+            }
+            catch (err) {
+                clearTimeout(timer);
+                if (logFailures) {
+                    logger.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, (0, __1._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();
+    });
 }
 exports.pRetry = pRetry;

package/dist/types.d.ts

@@ -24,13 +24,13 @@ export interface CreatedUpdated {
     created: number;
     updated: number;
 }
-export interface CreatedUpdatedId extends CreatedUpdated {
-    id: string;
+export interface CreatedUpdatedId<ID = string> extends CreatedUpdated {
+    id: ID;
 }
-export interface ObjectWithId {
-    id: string;
+export interface ObjectWithId<ID = string> {
+    id: ID;
 }
-export interface AnyObjectWithId extends AnyObject, ObjectWithId {
+export interface AnyObjectWithId<ID = string> extends AnyObject, ObjectWithId<ID> {
 }
 /**
  * Convenience type shorthand.
@@ -127,8 +127,8 @@ export declare type UnixTimestamp = number;
 /**
  * Base interface for any Entity that was saved to DB.
  */
-export interface SavedDBEntity {
-    id: string;
+export interface SavedDBEntity<ID = string> {
+    id: ID;
     /**
      * unixTimestamp of when the entity was first created (in the DB).
      */
@@ -144,9 +144,9 @@ export interface SavedDBEntity {
  * hence `id`, `created` and `updated` fields CAN BE undefined (yet).
  * When it's known to be saved - `SavedDBEntity` interface can be used instead.
  */
-export declare type BaseDBEntity = Partial<SavedDBEntity>;
-export declare type Saved<E> = Merge<E, SavedDBEntity>;
-export declare type Unsaved<E> = Merge<E, BaseDBEntity>;
+export declare type BaseDBEntity<ID = string> = Partial<SavedDBEntity<ID>>;
+export declare type Saved<E, ID = string> = Merge<E, SavedDBEntity<ID>>;
+export declare type Unsaved<E, ID = string> = Merge<E, BaseDBEntity<ID>>;
 /**
  * Named type for JSON.parse / JSON.stringify second argument
  */

package/dist-esm/decorators/retry.decorator.js

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

package/dist-esm/index.js

@@ -31,14 +31,13 @@ export * from './object/object.util';
 export * from './object/sortObject';
 export * from './object/sortObjectDeep';
 import { AggregatedError } from './promise/AggregatedError';
-export * from './promise/pBatch';
 import { pDefer } from './promise/pDefer';
 export * from './promise/pDelay';
 export * from './promise/pFilter';
 export * from './promise/pHang';
 import { pMap } from './promise/pMap';
 export * from './promise/pProps';
-import { pRetry } from './promise/pRetry';
+import { pRetry, pRetryFn } from './promise/pRetry';
 export * from './promise/pState';
 import { pTimeout, pTimeoutFn } from './promise/pTimeout';
 export * from './promise/pTuple';
@@ -55,4 +54,4 @@ export * from './string/safeJsonStringify';
 import { PQueue } from './promise/pQueue';
 export * from './seq/seq';
 export * from './math/stack.util';
-export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };
+export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pRetryFn, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };

package/dist-esm/json-schema/jsonSchemaBuilder.js

@@ -301,16 +301,16 @@ export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
         Object.assign(this.schema, { additionalProperties });
         return this;
     }
-    baseDBEntity() {
+    baseDBEntity(idType = 'string') {
         Object.assign(this.schema.properties, {
-            id: { type: 'string' },
+            id: { type: idType },
             created: { type: 'number', format: 'unixTimestamp' },
             updated: { type: 'number', format: 'unixTimestamp' },
         });
         return this;
     }
-    savedDBEntity() {
-        return this.baseDBEntity().addRequired(['id', 'created', 'updated']);
+    savedDBEntity(idType = 'string') {
+        return this.baseDBEntity(idType).addRequired(['id', 'created', 'updated']);
     }
     extend(s2) {
         const builder = new JsonSchemaObjectBuilder();

package/dist-esm/promise/AggregatedError.js

@@ -5,17 +5,12 @@
  */
 export class AggregatedError extends Error {
     constructor(errors, results = []) {
-        const mappedErrors = errors.map(e => {
-            if (typeof e === 'string')
-                return new Error(e);
-            return e;
-        });
         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', {
             value: this.constructor.name,

package/dist-esm/promise/pFilter.js

@@ -1,5 +1,5 @@
-import { pMap } from './pMap';
-export async function pFilter(iterable, filterFn, opt) {
-    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(iterable, filterFn) {
+    const items = [...iterable];
+    const predicates = await Promise.all(items.map((item, i) => filterFn(item, i)));
+    return items.filter((item, i) => predicates[i]);
 }