@naturalcycles/js-lib 14.78.1 → 14.81.0

package/dist/decorators/logMethod.decorator.js

@@ -56,7 +56,7 @@ function _LogMethod(opt = {}) {
                     })
                         .catch((err) => {
                         logFinished(logger, callSignature, started, sma, logResultFn, undefined, err);
-                        return Promise.reject(err);
+                        throw err;
                     });
                 }
                 else {

package/dist/decorators/memo.decorator.js

@@ -80,7 +80,7 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
                     // Wrap as Error if it's not Error
                     cache.get(ctx).set(cacheKey, err instanceof Error ? err : new Error(err));
                 }
-                return Promise.reject(err);
+                throw err;
             });
         }
         else {

package/dist/decorators/memoFn.js

@@ -49,7 +49,7 @@ function _memoFn(fn, opt = {}) {
                     // Wrap as Error if it's not Error
                     cache.set(cacheKey, err instanceof Error ? err : new Error(err));
                 }
-                return Promise.reject(err);
+                throw err;
             });
         }
         else {

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/error/try.js

@@ -27,8 +27,6 @@ function _try(fn) {
     }
 }
 exports._try = _try;
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
 /**
  * Like _try, but for Promises.
  *

package/dist/index.d.ts

@@ -41,7 +41,7 @@ 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 +60,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);
@@ -53,6 +53,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/pProps.d.ts

@@ -1,10 +1,19 @@
-import { PMapOptions } from './pMap';
 /**
  * Promise.all for Object instead of Array.
- * Supports concurrency.
+ *
+ * Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
+ *
+ * Improvements:
+ *
+ * - Exported as { pProps }, so IDE auto-completion works
+ * - Simpler: no support for Map, Mapper, Options
+ * - Included Typescript typings (no need for @types/p-props)
+ *
+ * Concurrency implementation via pMap was removed in favor of preserving async
+ * stack traces (more important!).
  */
 export declare function pProps<T>(input: {
     [K in keyof T]: T[K] | Promise<T[K]>;
-}, opt?: PMapOptions): Promise<{
+}): Promise<{
     [K in keyof T]: Awaited<T[K]>;
 }>;

package/dist/promise/pProps.js

@@ -1,26 +1,22 @@
 "use strict";
-/*
-Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
-
-Improvements:
-
-- Exported as { pProps }, so IDE auto-completion works
-- Simpler: no support for Map, Mapper, Options
-- Included Typescript typings (no need for @types/p-props)
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pProps = void 0;
-const pMap_1 = require("./pMap");
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
 /**
  * Promise.all for Object instead of Array.
- * Supports concurrency.
+ *
+ * Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
+ *
+ * Improvements:
+ *
+ * - Exported as { pProps }, so IDE auto-completion works
+ * - Simpler: no support for Map, Mapper, Options
+ * - Included Typescript typings (no need for @types/p-props)
+ *
+ * Concurrency implementation via pMap was removed in favor of preserving async
+ * stack traces (more important!).
  */
-async function pProps(input, opt) {
-    const r = {};
+async function pProps(input) {
     const keys = Object.keys(input);
-    await (0, pMap_1.pMap)(Object.values(input), (v, i) => (r[keys[i]] = v), opt);
-    return r;
+    return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]));
 }
 exports.pProps = pProps;

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 60_000
+     */
+    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/logMethod.decorator.js

@@ -53,7 +53,7 @@ export function _LogMethod(opt = {}) {
                     })
                         .catch((err) => {
                         logFinished(logger, callSignature, started, sma, logResultFn, undefined, err);
-                        return Promise.reject(err);
+                        throw err;
                     });
                 }
                 else {

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

@@ -77,7 +77,7 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
                     // Wrap as Error if it's not Error
                     cache.get(ctx).set(cacheKey, err instanceof Error ? err : new Error(err));
                 }
-                return Promise.reject(err);
+                throw err;
             });
         }
         else {

package/dist-esm/decorators/memoFn.js

@@ -46,7 +46,7 @@ export function _memoFn(fn, opt = {}) {
                     // Wrap as Error if it's not Error
                     cache.set(cacheKey, err instanceof Error ? err : new Error(err));
                 }
-                return Promise.reject(err);
+                throw err;
             });
         }
         else {

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/error/try.js

@@ -23,8 +23,6 @@ export function _try(fn) {
         return [err, undefined];
     }
 }
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
 /**
  * Like _try, but for Promises.
  *

package/dist-esm/index.js

@@ -38,7 +38,7 @@ 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 +55,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/pProps.js

@@ -1,22 +1,18 @@
-/*
-Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
-
-Improvements:
-
-- Exported as { pProps }, so IDE auto-completion works
-- Simpler: no support for Map, Mapper, Options
-- Included Typescript typings (no need for @types/p-props)
- */
-import { pMap } from './pMap';
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
 /**
  * Promise.all for Object instead of Array.
- * Supports concurrency.
+ *
+ * Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
+ *
+ * Improvements:
+ *
+ * - Exported as { pProps }, so IDE auto-completion works
+ * - Simpler: no support for Map, Mapper, Options
+ * - Included Typescript typings (no need for @types/p-props)
+ *
+ * Concurrency implementation via pMap was removed in favor of preserving async
+ * stack traces (more important!).
  */
-export async function pProps(input, opt) {
-    const r = {};
+export async function pProps(input) {
     const keys = Object.keys(input);
-    await pMap(Object.values(input), (v, i) => (r[keys[i]] = v), opt);
-    return r;
+    return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]));
 }

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.78.1",
+  "version": "14.81.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/decorators/logMethod.decorator.ts

@@ -110,7 +110,7 @@ export function _LogMethod(opt: LogMethodOptions = {}): MethodDecorator {
             })
             .catch((err: any) => {
               logFinished(logger, callSignature, started, sma, logResultFn, undefined, err)
-              return Promise.reject(err)
+              throw err
             })
         } else {
           // not a Promise

package/src/decorators/memo.decorator.ts

@@ -163,7 +163,7 @@ export const _Memo =
               cache.get(ctx)!.set(cacheKey, err instanceof Error ? err : new Error(err))
             }
 
-            return Promise.reject(err)
+            throw err
           })
       } else {
         if (logMiss) {

package/src/decorators/memoFn.ts

@@ -83,7 +83,7 @@ export function _memoFn<T extends (...args: any[]) => any>(
             cache.set(cacheKey, err instanceof Error ? err : new Error(err))
           }
 
-          return Promise.reject(err)
+          throw err
         }) as any
     } else {
       if (logMiss) {

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/error/try.ts

@@ -27,9 +27,6 @@ export function _try<ERR = unknown, RETURN = void>(
   }
 }
 
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
-
 /**
  * Like _try, but for Promises.
  *

package/src/index.ts

@@ -74,7 +74,7 @@ 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 +250,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/pProps.ts

@@ -1,28 +1,20 @@
-/*
-Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
-
-Improvements:
-
-- Exported as { pProps }, so IDE auto-completion works
-- Simpler: no support for Map, Mapper, Options
-- Included Typescript typings (no need for @types/p-props)
- */
-
-import { pMap, PMapOptions } from './pMap'
-
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
-
 /**
  * Promise.all for Object instead of Array.
- * Supports concurrency.
+ *
+ * Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
+ *
+ * Improvements:
+ *
+ * - Exported as { pProps }, so IDE auto-completion works
+ * - Simpler: no support for Map, Mapper, Options
+ * - Included Typescript typings (no need for @types/p-props)
+ *
+ * Concurrency implementation via pMap was removed in favor of preserving async
+ * stack traces (more important!).
  */
-export async function pProps<T>(
-  input: { [K in keyof T]: T[K] | Promise<T[K]> },
-  opt?: PMapOptions,
-): Promise<{ [K in keyof T]: Awaited<T[K]> }> {
-  const r = {} as { [K in keyof T]: Awaited<T[K]> }
-  const keys = Object.keys(input) as (keyof T)[]
-  await pMap(Object.values(input), (v, i) => (r[keys[i]!] = v), opt)
-  return r
+export async function pProps<T>(input: { [K in keyof T]: T[K] | Promise<T[K]> }): Promise<{
+  [K in keyof T]: Awaited<T[K]>
+}> {
+  const keys = Object.keys(input)
+  return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]))
 }

package/src/promise/pRetry.ts

@@ -1,4 +1,5 @@
 import { _since, _stringifyAny, AnyFunction, CommonLogger } from '..'
+import { TimeoutError } from './pTimeout'
 
 export interface PRetryOptions {
   /**
@@ -7,6 +8,13 @@ export interface PRetryOptions {
    */
   name?: string
 
+  /**
+   * Timeout for each Try, in milliseconds.
+   *
+   * Defaults to 60_000
+   */
+  timeout?: number
+
   /**
    * How many attempts to try.
    * First attempt is not a retry, but "initial try". It still counts.
@@ -34,7 +42,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).
@@ -74,76 +82,132 @@ 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.
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function pRetry<T extends AnyFunction>(fn: T, opt: PRetryOptions = {}): T {
+export function pRetryFn<T extends AnyFunction>(fn: T, opt: PRetryOptions = {}): T {
+  return async function pRetryFunction(this: any, ...args: any[]) {
+    return await pRetry(() => fn.call(this, ...args), opt)
+  } as any
+}
+
+export async function pRetry<T>(
+  fn: (attempt: number) => Promise<T>,
+  opt: PRetryOptions = {},
+): Promise<T> {
   const {
     maxAttempts = 4,
     delay: initialDelay = 1000,
     delayMultiplier = 2,
     predicate,
     logger = console,
-    name = fn.name,
+    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('.')
+  const fname = name || fn.name || 'pRetry function'
 
-  return async function (this: any, ...args: any[]) {
-    let delay = initialDelay
-    let attempt = 0
+  let delay = initialDelay
+  let attempt = 0
+  let timer: NodeJS.Timeout | undefined
+  let timedOut = false
 
-    return await new Promise((resolve, reject) => {
-      const next = async () => {
-        const started = Date.now()
+  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)
+    }
 
-        try {
-          attempt++
-          if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
-            logger.log(`${fname} attempt #${attempt}...`)
-          }
+    const next = async () => {
+      if (timedOut) return
 
-          const r = await fn.apply(this, args)
+      if (timeout) {
+        timer = setTimeout(rejectWithTimeout, timeout)
+      }
 
-          if (logSuccess) {
-            logger.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`)
-          }
-          resolve(r)
-        } catch (err) {
-          if (logFailures) {
-            logger.warn(
-              `${fname} attempt #${attempt} error in ${_since(started)}:`,
-              _stringifyAny(err, {
-                includeErrorData: true,
-              }),
-            )
-          }
+      const started = Date.now()
+
+      try {
+        attempt++
+        if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
+          logger.log(`${fname} attempt #${attempt}...`)
+        }
+
+        const r = await fn(attempt)
+
+        clearTimeout(timer!)
 
-          if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
-            // Give up
-            reject(err)
-          } else {
-            // Retry after delay
-            delay *= delayMultiplier
-            setTimeout(next, delay)
+        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 as Error, attempt, maxAttempts))
+        ) {
+          // Give up
+
+          if (fakeError) {
+            // Preserve the original call stack
+            Object.defineProperty(err, 'stack', {
+              value:
+                (err as Error).stack +
+                '\n    --' +
+                fakeError.stack!.replace('Error: RetryError', ''),
+            })
           }
+
+          reject(err)
+        } else {
+          // Retry after delay
+          delay *= delayMultiplier
+          setTimeout(next, delay)
         }
       }
+    }
 
-      void next()
-    })
-  } as any
+    void next()
+  })
 }

package/src/types.ts

@@ -29,15 +29,15 @@ export interface CreatedUpdated {
   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.
@@ -169,8 +169,8 @@ export 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).
@@ -189,10 +189,10 @@ 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 type BaseDBEntity = Partial<SavedDBEntity>
+export type BaseDBEntity<ID = string> = Partial<SavedDBEntity<ID>>
 
-export type Saved<E> = Merge<E, SavedDBEntity>
-export type Unsaved<E> = Merge<E, BaseDBEntity>
+export type Saved<E, ID = string> = Merge<E, SavedDBEntity<ID>>
+export type Unsaved<E, ID = string> = Merge<E, BaseDBEntity<ID>>
 
 /**
  * Named type for JSON.parse / JSON.stringify second argument