@naturalcycles/js-lib 14.83.0 → 14.84.2

package/dist/decorators/asyncMemo.decorator.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._AsyncMemo = void 0;
 const time_util_1 = require("../time/time.util");
 const decorator_util_1 = require("./decorator.util");
-const memo_decorator_1 = require("./memo.decorator");
 const memo_util_1 = require("./memo.util");
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
@@ -30,18 +29,6 @@ const _AsyncMemo = (opt) => (target, key, descriptor) => {
             // here, no need to check the cache. It's definitely a miss, because the cacheLayers is just created
             // UPD: no! AsyncMemo supports "persistent caches" (e.g Database-backed cache)
         }
-        if (args.length === 1 && args[0] === memo_decorator_1.CACHE_DROP) {
-            // Special event - CACHE_DROP
-            // Function will return undefined
-            logger.log(`${methodSignature} @_AsyncMemo.dropCache()`);
-            try {
-                await Promise.all(cache.get(ctx).map(c => c.clear()));
-            }
-            catch (err) {
-                logger.error(err);
-            }
-            return;
-        }
         let value;
         try {
             for await (const cacheLayer of cache.get(ctx)) {
@@ -91,6 +78,16 @@ const _AsyncMemo = (opt) => (target, key, descriptor) => {
             }
         }
     };
+    descriptor.value.dropCache = async () => {
+        logger.log(`${methodSignature} @_AsyncMemo.dropCache()`);
+        try {
+            await Promise.all([...cache.values()].flatMap(c => c.map(c => c.clear())));
+            cache.clear();
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    };
     return descriptor;
 };
 exports._AsyncMemo = _AsyncMemo;

package/dist/decorators/memo.decorator.d.ts

@@ -1,9 +1,5 @@
 import { CommonLogger } from '../log/commonLogger';
 import { MemoCache } from './memo.util';
-/**
- * Symbol to indicate that the Cache should be dropped.
- */
-export declare const CACHE_DROP: unique symbol;
 export interface MemoOptions {
     /**
      * Default to false

package/dist/decorators/memo.decorator.js

@@ -5,14 +5,10 @@
 // http://inlehmansterms.net/2015/03/01/javascript-memoization/
 // https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._Memo = exports.CACHE_DROP = void 0;
+exports._Memo = void 0;
 const time_util_1 = require("../time/time.util");
 const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
-/**
- * Symbol to indicate that the Cache should be dropped.
- */
-exports.CACHE_DROP = Symbol('CACHE_DROP');
 /**
  * Memoizes the method of the class, so it caches the output and returns the cached version if the "key"
  * of the cache is the same. Key, by defaul, is calculated as `JSON.stringify(...args)`.
@@ -43,12 +39,6 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = function (...args) {
         const ctx = this;
-        if (args.length === 1 && args[0] === exports.CACHE_DROP) {
-            // Special event - CACHE_DROP
-            // Function will return undefined
-            logger.log(`${methodSignature} @_Memo.CACHE_DROP`);
-            return cache.get(ctx)?.clear();
-        }
         const cacheKey = cacheKeyFn(args);
         if (!cache.has(ctx)) {
             cache.set(ctx, cacheFactory());
@@ -101,6 +91,11 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
             return res;
         }
     };
+    descriptor.value.dropCache = () => {
+        logger.log(`${methodSignature} @_Memo.dropCache()`);
+        cache.forEach(memoCache => memoCache.clear());
+        cache.clear();
+    };
     return descriptor;
 };
 exports._Memo = _Memo;

package/dist/decorators/memo.util.d.ts

@@ -1,3 +1,4 @@
+import { Promisable } from '../typeFest';
 export declare type MemoSerializer = (args: any[]) => any;
 export declare const jsonMemoSerializer: MemoSerializer;
 export interface MemoCache<KEY = any, VALUE = any> {
@@ -16,24 +17,18 @@ export interface AsyncMemoCache<KEY = any, VALUE = any> {
      * This also means that you CANNOT store `undefined` value in the Cache, as it'll be treated as a MISS.
      * You CAN store `null` value instead, it will be treated as a HIT.
      */
-    get(k: KEY): Promise<VALUE | undefined>;
-    set(k: KEY, v: VALUE): Promise<void>;
+    get(k: KEY): Promisable<VALUE | undefined>;
+    set(k: KEY, v: VALUE): Promisable<void>;
     /**
      * Clear is only called when `.dropCache()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
      */
-    clear(): Promise<void>;
+    clear(): Promisable<void>;
 }
-export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE> {
+export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE>, AsyncMemoCache<KEY, VALUE> {
     private m;
     has(k: KEY): boolean;
     get(k: KEY): VALUE | undefined;
     set(k: KEY, v: VALUE): void;
     clear(): void;
 }
-export declare class MapAsyncMemoCache<KEY = any, VALUE = any> implements AsyncMemoCache<KEY, VALUE> {
-    private m;
-    get(k: KEY): Promise<VALUE | undefined>;
-    set(k: KEY, v: VALUE): Promise<void>;
-    clear(): Promise<void>;
-}

package/dist/decorators/memo.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapAsyncMemoCache = exports.MapMemoCache = exports.jsonMemoSerializer = void 0;
+exports.MapMemoCache = exports.jsonMemoSerializer = void 0;
 const object_util_1 = require("../object/object.util");
 const jsonMemoSerializer = args => {
     if (args.length === 0)
@@ -73,18 +73,3 @@ class MapMemoCache {
     }
 }
 exports.MapMemoCache = MapMemoCache;
-class MapAsyncMemoCache {
-    constructor() {
-        this.m = new Map();
-    }
-    async get(k) {
-        return this.m.get(k);
-    }
-    async set(k, v) {
-        this.m.set(k, v);
-    }
-    async clear() {
-        this.m.clear();
-    }
-}
-exports.MapAsyncMemoCache = MapAsyncMemoCache;

package/dist/error/assert.d.ts

@@ -1,4 +1,4 @@
-import { ErrorData, HttpErrorData } from '..';
+import { ErrorData } from '..';
 import { AppError } from './app.error';
 /**
  * Evaluates the `condition` (casts it to Boolean).
@@ -16,21 +16,21 @@ import { AppError } from './app.error';
  * 3. Sets `userFriendly` flag to true, cause it's always better to have at least SOME clue, rather than fully generic "Oops" error.
  */
 export declare function _assert(condition: any, // will be evaluated as Boolean
-message?: string, errorData?: Partial<HttpErrorData>): asserts condition;
+message?: string, errorData?: ErrorData): asserts condition;
 /**
  * Like _assert(), but prints more helpful error message.
  * API is similar to Node's assert.equals().
  *
  * Does SHALLOW, but strict equality (===), use _assertDeepEquals() for deep equality.
  */
-export declare function _assertEquals<T>(actual: any, expected: T, message?: string, errorData?: Partial<HttpErrorData>): asserts actual is T;
+export declare function _assertEquals<T>(actual: any, expected: T, message?: string, errorData?: ErrorData): asserts actual is T;
 /**
  * Like _assert(), but prints more helpful error message.
  * API is similar to Node's assert.deepEquals().
  *
  * Does DEEP equality via _deepEquals()
  */
-export declare function _assertDeepEquals<T>(actual: any, expected: T, message?: string, errorData?: Partial<HttpErrorData>): asserts actual is T;
+export declare function _assertDeepEquals<T>(actual: any, expected: T, message?: string, errorData?: ErrorData): asserts actual is T;
 export declare function _assertIsError<ERR extends Error = Error>(err: any, message?: string): asserts err is ERR;
 export declare function _assertIsString(v: any, message?: string): asserts v is string;
 export declare function _assertIsNumber(v: any, message?: string): asserts v is number;

package/dist/error/error.model.d.ts

@@ -32,6 +32,7 @@ export interface ErrorData {
      * Can be used to force-group errors that are NOT needed to be split by endpoint or calling function.
      */
     fingerprint?: string[];
+    httpStatusCode?: number;
     /**
      * Open-ended.
      */

package/dist/promise/pRetry.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction, CommonLogger } from '..';
+import { AnyFunction, CommonLogger, ErrorData } from '..';
 export interface PRetryOptions {
     /**
      * If set - will be included in the error message.
@@ -76,6 +76,10 @@ export interface PRetryOptions {
      * @experimental
      */
     keepStackTrace?: boolean;
+    /**
+     * Will be merged with `err.data` object.
+     */
+    errorData?: ErrorData;
 }
 /**
  * Returns a Function (!), enhanced with retry capabilities.

package/dist/promise/pRetry.js

@@ -31,7 +31,7 @@ async function pRetry(fn, opt = {}) {
     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`);
+            const err = new pTimeout_1.TimeoutError(`"${fname}" timed out after ${timeout} ms`, opt.errorData);
             if (fakeError) {
                 // keep original stack
                 err.stack = fakeError.stack.replace('Error: RetryError', 'TimeoutError');
@@ -75,6 +75,11 @@ async function pRetry(fn, opt = {}) {
                                 fakeError.stack.replace('Error: RetryError', ''),
                         });
                     }
+                    ;
+                    err.data = {
+                        ...err.data,
+                        ...opt.errorData,
+                    };
                     reject(err);
                 }
                 else {

package/dist/promise/pTimeout.d.ts

@@ -1,4 +1,5 @@
 import { AppError } from '../error/app.error';
+import { ErrorData } from '../error/error.model';
 import { AnyFunction } from '../types';
 export declare class TimeoutError extends AppError {
 }
@@ -25,6 +26,10 @@ export interface PTimeoutOptions {
      * @experimental
      */
     keepStackTrace?: boolean;
+    /**
+     * Will be merged with `err.data` object.
+     */
+    errorData?: ErrorData;
 }
 /**
  * Decorates a Function with a timeout.

package/dist/promise/pTimeout.js

@@ -37,11 +37,15 @@ async function pTimeout(promise, opt) {
                 catch (err) {
                     if (fakeError)
                         err.stack = fakeError.stack; // keep original stack
+                    err.data = {
+                        ...err.data,
+                        ...opt.errorData,
+                    };
                     reject(err);
                 }
                 return;
             }
-            const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`);
+            const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`, opt.errorData);
             if (fakeError)
                 err.stack = fakeError.stack; // keep original stack
             reject(err);

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

@@ -1,7 +1,6 @@
 import { __asyncValues } from "tslib";
 import { _since } from '../time/time.util';
 import { _getArgsSignature, _getMethodSignature, _getTargetMethodSignature } from './decorator.util';
-import { CACHE_DROP } from './memo.decorator';
 import { jsonMemoSerializer } from './memo.util';
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
@@ -29,18 +28,6 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
             // here, no need to check the cache. It's definitely a miss, because the cacheLayers is just created
             // UPD: no! AsyncMemo supports "persistent caches" (e.g Database-backed cache)
         }
-        if (args.length === 1 && args[0] === CACHE_DROP) {
-            // Special event - CACHE_DROP
-            // Function will return undefined
-            logger.log(`${methodSignature} @_AsyncMemo.dropCache()`);
-            try {
-                await Promise.all(cache.get(ctx).map(c => c.clear()));
-            }
-            catch (err) {
-                logger.error(err);
-            }
-            return;
-        }
         let value;
         try {
             try {
@@ -100,5 +87,15 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
             }
         }
     };
+    descriptor.value.dropCache = async () => {
+        logger.log(`${methodSignature} @_AsyncMemo.dropCache()`);
+        try {
+            await Promise.all([...cache.values()].flatMap(c => c.map(c => c.clear())));
+            cache.clear();
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    };
     return descriptor;
 };

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

@@ -6,10 +6,6 @@
 import { _since } from '../time/time.util';
 import { _getArgsSignature, _getMethodSignature, _getTargetMethodSignature } from './decorator.util';
 import { jsonMemoSerializer, MapMemoCache } from './memo.util';
-/**
- * Symbol to indicate that the Cache should be dropped.
- */
-export const CACHE_DROP = Symbol('CACHE_DROP');
 /**
  * Memoizes the method of the class, so it caches the output and returns the cached version if the "key"
  * of the cache is the same. Key, by defaul, is calculated as `JSON.stringify(...args)`.
@@ -39,14 +35,7 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {
-        var _a;
         const ctx = this;
-        if (args.length === 1 && args[0] === CACHE_DROP) {
-            // Special event - CACHE_DROP
-            // Function will return undefined
-            logger.log(`${methodSignature} @_Memo.CACHE_DROP`);
-            return (_a = cache.get(ctx)) === null || _a === void 0 ? void 0 : _a.clear();
-        }
         const cacheKey = cacheKeyFn(args);
         if (!cache.has(ctx)) {
             cache.set(ctx, cacheFactory());
@@ -99,5 +88,10 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
             return res;
         }
     };
+    descriptor.value.dropCache = () => {
+        logger.log(`${methodSignature} @_Memo.dropCache()`);
+        cache.forEach(memoCache => memoCache.clear());
+        cache.clear();
+    };
     return descriptor;
 };

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

@@ -68,17 +68,3 @@ export class MapMemoCache {
         this.m.clear();
     }
 }
-export class MapAsyncMemoCache {
-    constructor() {
-        this.m = new Map();
-    }
-    async get(k) {
-        return this.m.get(k);
-    }
-    async set(k, v) {
-        this.m.set(k, v);
-    }
-    async clear() {
-        this.m.clear();
-    }
-}

package/dist-esm/promise/pRetry.js

@@ -27,7 +27,7 @@ export async function pRetry(fn, opt = {}) {
     return await new Promise((resolve, reject) => {
         const rejectWithTimeout = () => {
             timedOut = true; // to prevent more tries
-            const err = new TimeoutError(`"${fname}" timed out after ${timeout} ms`);
+            const err = new TimeoutError(`"${fname}" timed out after ${timeout} ms`, opt.errorData);
             if (fakeError) {
                 // keep original stack
                 err.stack = fakeError.stack.replace('Error: RetryError', 'TimeoutError');
@@ -71,6 +71,8 @@ export async function pRetry(fn, opt = {}) {
                                 fakeError.stack.replace('Error: RetryError', ''),
                         });
                     }
+                    ;
+                    err.data = Object.assign(Object.assign({}, err.data), opt.errorData);
                     reject(err);
                 }
                 else {

package/dist-esm/promise/pTimeout.js

@@ -32,11 +32,12 @@ export async function pTimeout(promise, opt) {
                 catch (err) {
                     if (fakeError)
                         err.stack = fakeError.stack; // keep original stack
+                    err.data = Object.assign(Object.assign({}, err.data), opt.errorData);
                     reject(err);
                 }
                 return;
             }
-            const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`);
+            const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`, opt.errorData);
             if (fakeError)
                 err.stack = fakeError.stack; // keep original stack
             reject(err);

package/package.json

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

package/src/decorators/asyncMemo.decorator.ts

@@ -2,7 +2,7 @@ import { _since } from '../time/time.util'
 import { Merge } from '../typeFest'
 import { AnyObject } from '../types'
 import { _getArgsSignature, _getMethodSignature, _getTargetMethodSignature } from './decorator.util'
-import { CACHE_DROP, MemoOptions } from './memo.decorator'
+import { MemoOptions } from './memo.decorator'
 import { AsyncMemoCache, jsonMemoSerializer } from './memo.util'
 
 export type AsyncMemoOptions = Merge<
@@ -65,19 +65,6 @@ export const _AsyncMemo =
         // UPD: no! AsyncMemo supports "persistent caches" (e.g Database-backed cache)
       }
 
-      if (args.length === 1 && args[0] === CACHE_DROP) {
-        // Special event - CACHE_DROP
-        // Function will return undefined
-        logger.log(`${methodSignature} @_AsyncMemo.dropCache()`)
-        try {
-          await Promise.all(cache.get(ctx)!.map(c => c.clear()))
-        } catch (err) {
-          logger.error(err)
-        }
-
-        return
-      }
-
       let value: any
 
       try {
@@ -146,6 +133,15 @@ export const _AsyncMemo =
         }
       }
     } as any
+    ;(descriptor.value as any).dropCache = async () => {
+      logger.log(`${methodSignature} @_AsyncMemo.dropCache()`)
+      try {
+        await Promise.all([...cache.values()].flatMap(c => c.map(c => c.clear())))
+        cache.clear()
+      } catch (err) {
+        logger.error(err)
+      }
+    }
 
     return descriptor
   }

package/src/decorators/memo.decorator.ts

@@ -10,11 +10,6 @@ import { AnyObject } from '../types'
 import { _getArgsSignature, _getMethodSignature, _getTargetMethodSignature } from './decorator.util'
 import { jsonMemoSerializer, MapMemoCache, MemoCache } from './memo.util'
 
-/**
- * Symbol to indicate that the Cache should be dropped.
- */
-export const CACHE_DROP = Symbol('CACHE_DROP')
-
 export interface MemoOptions {
   /**
    * Default to false
@@ -111,13 +106,6 @@ export const _Memo =
     descriptor.value = function (this: typeof target, ...args: any[]): any {
       const ctx = this
 
-      if (args.length === 1 && args[0] === CACHE_DROP) {
-        // Special event - CACHE_DROP
-        // Function will return undefined
-        logger.log(`${methodSignature} @_Memo.CACHE_DROP`)
-        return cache.get(ctx)?.clear()
-      }
-
       const cacheKey = cacheKeyFn(args)
 
       if (!cache.has(ctx)) {
@@ -195,6 +183,11 @@ export const _Memo =
         return res
       }
     } as any
+    ;(descriptor.value as any).dropCache = () => {
+      logger.log(`${methodSignature} @_Memo.dropCache()`)
+      cache.forEach(memoCache => memoCache.clear())
+      cache.clear()
+    }
 
     return descriptor
   }

package/src/decorators/memo.util.ts

@@ -1,4 +1,5 @@
 import { _isPrimitive } from '../object/object.util'
+import { Promisable } from '../typeFest'
 
 export type MemoSerializer = (args: any[]) => any
 
@@ -28,14 +29,14 @@ export interface AsyncMemoCache<KEY = any, VALUE = any> {
    * This also means that you CANNOT store `undefined` value in the Cache, as it'll be treated as a MISS.
    * You CAN store `null` value instead, it will be treated as a HIT.
    */
-  get(k: KEY): Promise<VALUE | undefined>
-  set(k: KEY, v: VALUE): Promise<void>
+  get(k: KEY): Promisable<VALUE | undefined>
+  set(k: KEY, v: VALUE): Promisable<void>
 
   /**
    * Clear is only called when `.dropCache()` is called.
    * Otherwise the Cache is "persistent" (never cleared).
    */
-  clear(): Promise<void>
+  clear(): Promisable<void>
 }
 
 // SingleValueMemoCache and ObjectMemoCache are example-only, not used in production code
@@ -84,7 +85,9 @@ export class ObjectMemoCache implements MemoCache {
 }
  */
 
-export class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE> {
+export class MapMemoCache<KEY = any, VALUE = any>
+  implements MemoCache<KEY, VALUE>, AsyncMemoCache<KEY, VALUE>
+{
   private m = new Map<KEY, VALUE>()
 
   has(k: KEY): boolean {
@@ -103,19 +106,3 @@ export class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALU
     this.m.clear()
   }
 }
-
-export class MapAsyncMemoCache<KEY = any, VALUE = any> implements AsyncMemoCache<KEY, VALUE> {
-  private m = new Map<KEY, VALUE>()
-
-  async get(k: KEY): Promise<VALUE | undefined> {
-    return this.m.get(k)
-  }
-
-  async set(k: KEY, v: VALUE): Promise<void> {
-    this.m.set(k, v)
-  }
-
-  async clear(): Promise<void> {
-    this.m.clear()
-  }
-}

package/src/error/assert.ts

@@ -1,4 +1,4 @@
-import { ErrorData, HttpErrorData, _deepEquals, _stringifyAny } from '..'
+import { ErrorData, _deepEquals, _stringifyAny } from '..'
 import { AppError } from './app.error'
 
 /**
@@ -19,7 +19,7 @@ import { AppError } from './app.error'
 export function _assert(
   condition: any, // will be evaluated as Boolean
   message?: string,
-  errorData?: Partial<HttpErrorData>,
+  errorData?: ErrorData,
 ): asserts condition {
   if (!condition) {
     throw new AssertionError(message || 'see stacktrace', {
@@ -39,7 +39,7 @@ export function _assertEquals<T>(
   actual: any,
   expected: T,
   message?: string,
-  errorData?: Partial<HttpErrorData>,
+  errorData?: ErrorData,
 ): asserts actual is T {
   if (actual !== expected) {
     const msg = [
@@ -67,7 +67,7 @@ export function _assertDeepEquals<T>(
   actual: any,
   expected: T,
   message?: string,
-  errorData?: Partial<HttpErrorData>,
+  errorData?: ErrorData,
 ): asserts actual is T {
   if (!_deepEquals(actual, expected)) {
     const msg = [

package/src/error/error.model.ts

@@ -38,6 +38,8 @@ export interface ErrorData {
    */
   fingerprint?: string[]
 
+  httpStatusCode?: number
+
   /**
    * Open-ended.
    */

package/src/promise/pRetry.ts

@@ -1,4 +1,4 @@
-import { _since, _stringifyAny, AnyFunction, CommonLogger } from '..'
+import { _since, _stringifyAny, AnyFunction, AppError, CommonLogger, ErrorData } from '..'
 import { TimeoutError } from './pTimeout'
 
 export interface PRetryOptions {
@@ -91,6 +91,11 @@ export interface PRetryOptions {
    * @experimental
    */
   keepStackTrace?: boolean
+
+  /**
+   * Will be merged with `err.data` object.
+   */
+  errorData?: ErrorData
 }
 
 /**
@@ -139,7 +144,7 @@ export async function pRetry<T>(
   return await new Promise((resolve, reject) => {
     const rejectWithTimeout = () => {
       timedOut = true // to prevent more tries
-      const err = new TimeoutError(`"${fname}" timed out after ${timeout} ms`)
+      const err = new TimeoutError(`"${fname}" timed out after ${timeout} ms`, opt.errorData)
       if (fakeError) {
         // keep original stack
         err.stack = fakeError.stack!.replace('Error: RetryError', 'TimeoutError')
@@ -199,6 +204,11 @@ export async function pRetry<T>(
             })
           }
 
+          ;(err as AppError).data = {
+            ...(err as AppError).data,
+            ...opt.errorData,
+          }
+
           reject(err)
         } else {
           // Retry after delay

package/src/promise/pTimeout.ts

@@ -1,4 +1,5 @@
 import { AppError } from '../error/app.error'
+import { ErrorData } from '../error/error.model'
 import { AnyFunction } from '../types'
 
 export class TimeoutError extends AppError {}
@@ -29,6 +30,11 @@ export interface PTimeoutOptions {
    * @experimental
    */
   keepStackTrace?: boolean
+
+  /**
+   * Will be merged with `err.data` object.
+   */
+  errorData?: ErrorData
 }
 
 /**
@@ -63,12 +69,19 @@ export async function pTimeout<T>(promise: Promise<T>, opt: PTimeoutOptions): Pr
           resolve(onTimeout())
         } catch (err: any) {
           if (fakeError) err.stack = fakeError.stack // keep original stack
+          err.data = {
+            ...err.data,
+            ...opt.errorData,
+          }
           reject(err)
         }
         return
       }
 
-      const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`)
+      const err = new TimeoutError(
+        `"${name || 'pTimeout function'}" timed out after ${timeout} ms`,
+        opt.errorData,
+      )
       if (fakeError) err.stack = fakeError.stack // keep original stack
       reject(err)
     }, timeout)