@naturalcycles/js-lib 14.129.0 → 14.130.1

package/dist-esm/error/error.util.js

@@ -1,4 +1,4 @@
-import { AppError, _jsonParseIfPossible, _stringifyAny } from '..';
+import { _jsonParseIfPossible, _stringifyAny } from '..';
 /**
  * Useful to ensure that error in `catch (err) { ... }`
  * is indeed an Error (and not e.g `string` or `undefined`).
@@ -7,14 +7,14 @@ import { AppError, _jsonParseIfPossible, _stringifyAny } from '..';
  *
  * Alternatively, if you're sure it's Error - you can use `_assertIsError(err)`.
  */
-export function _anyToError(o, errorClass = Error, errorData, opt) {
+export function _anyToError(o, errorClass = Error, errorData) {
     let e;
     if (o instanceof errorClass) {
         e = o;
     }
     else {
         // If it's an instance of Error, but ErrorClass is something else (e.g AppError) - it'll be "repacked" into AppError
-        const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, {}, opt);
+        const errorObject = _anyToErrorObject(o);
         e = _errorObjectToError(errorObject, errorClass);
     }
     if (errorData) {
@@ -29,11 +29,10 @@ export function _anyToError(o, errorClass = Error, errorData, opt) {
  * If object is Error - Error.message will be used.
  * Objects (not Errors) get converted to prettified JSON string (via `_stringifyAny`).
  */
-export function _anyToErrorObject(o, errorData, opt) {
-    var _a;
+export function _anyToErrorObject(o, errorData) {
     let eo;
     if (o instanceof Error) {
-        eo = _errorToErrorObject(o, (_a = opt === null || opt === void 0 ? void 0 : opt.includeErrorStack) !== null && _a !== void 0 ? _a : true);
+        eo = _errorToErrorObject(o);
     }
     else {
         o = _jsonParseIfPossible(o);
@@ -48,7 +47,7 @@ export function _anyToErrorObject(o, errorData, opt) {
             // so, fair to return `data: {}` in the end
             // Also we're sure it includes no "error name", e.g no `Error: ...`,
             // so, fair to include `name: 'Error'`
-            const message = _stringifyAny(o, Object.assign({ includeErrorData: true }, opt));
+            const message = _stringifyAny(o);
             eo = {
                 name: 'Error',
                 message,
@@ -59,20 +58,18 @@ export function _anyToErrorObject(o, errorData, opt) {
     Object.assign(eo.data, errorData);
     return eo;
 }
-export function _errorToErrorObject(e, includeErrorStack = true) {
+export function _errorToErrorObject(e) {
     const obj = {
         name: e.name,
         message: e.message,
-        data: Object.assign({}, e.data), // empty by default
+        data: Object.assign({}, e.data),
+        stack: e.stack,
     };
-    if (includeErrorStack) {
-        obj.stack = e.stack;
+    if (e.cause) {
+        obj.cause = _anyToErrorObject(e.cause);
     }
     return obj;
 }
-export function _errorObjectToAppError(o) {
-    return _errorObjectToError(o, AppError);
-}
 export function _errorObjectToError(o, errorClass = Error) {
     if (o instanceof errorClass)
         return o;
@@ -94,6 +91,14 @@ export function _errorObjectToError(o, errorClass = Error) {
             value: o.stack,
         });
     }
+    if (o.cause) {
+        Object.defineProperty(err, 'cause', {
+            value: o.cause,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+    }
     return err;
 }
 export function _isHttpErrorResponse(o) {
@@ -110,8 +115,15 @@ export function _isHttpErrorObject(o) {
  * Note: any instance of AppError is also automatically an ErrorObject
  */
 export function _isErrorObject(o) {
-    return (!!o && typeof o.name === 'string' && typeof o.message === 'string' && typeof o.data === 'object');
+    return (!!o &&
+        typeof o === 'object' &&
+        typeof o.name === 'string' &&
+        typeof o.message === 'string' &&
+        typeof o.data === 'object');
 }
+// export function _isErrorLike(o: any): o is ErrorLike {
+//   return !!o && typeof o === 'object' && typeof o.name === 'string' && typeof o.message === 'string'
+// }
 /**
  * Convenience function to safely add properties to Error's `data` object
  * (even if it wasn't previously existing)

package/dist-esm/error/errorMode.js

@@ -10,7 +10,7 @@ export var ErrorMode;
      */
     ErrorMode["THROW_IMMEDIATELY"] = "THROW_IMMEDIATELY";
     /**
-     * Don't throw on errors, but collect them and throw as AggregatedError in the end.
+     * Don't throw on errors, but collect them and throw as AggregateError in the end.
      */
     ErrorMode["THROW_AGGREGATED"] = "THROW_AGGREGATED";
     /**

package/dist-esm/error/http.error.js

@@ -3,7 +3,7 @@ import { AppError } from './app.error';
  * Base class for HTTP errors - errors that define HTTP error code.
  */
 export class HttpError extends AppError {
-    constructor(message, data) {
-        super(message, data);
+    constructor(message, data, opt) {
+        super(message, data, opt);
     }
 }

package/dist-esm/http/fetcher.js

@@ -159,11 +159,12 @@ export class Fetcher {
                                 res.body = JSON.parse(text, req.jsonReviver);
                             }
                             catch (err) {
-                                res.ok = false;
-                                res.err = _anyToError(err, HttpError, _filterNullishValues({
+                                const { message } = _anyToError(err);
+                                res.err = new HttpError([signature, message].join('\n'), {
                                     httpStatusCode: 0,
                                     url: req.url,
-                                }));
+                                });
+                                res.ok = false;
                             }
                         }
                         else {

package/dist-esm/index.js

@@ -37,7 +37,6 @@ export * from './object/deepEquals';
 export * from './object/object.util';
 export * from './object/sortObject';
 export * from './object/sortObjectDeep';
-export * from './promise/AggregatedError';
 export * from './promise/pDefer';
 export * from './promise/pDelay';
 export * from './promise/pFilter';

package/dist-esm/promise/pMap.js

@@ -8,7 +8,6 @@ Improvements:
  */
 import { __asyncValues } from "tslib";
 import { END, ErrorMode, SKIP } from '..';
-import { AggregatedError } from './AggregatedError';
 /**
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
@@ -86,7 +85,7 @@ export async function pMap(iterable, mapper, opt = {}) {
             finally { if (e_1) throw e_1.error; }
         }
         if (errors.length) {
-            throw new AggregatedError(errors, ret);
+            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
         }
         return ret;
     }
@@ -106,7 +105,7 @@ export async function pMap(iterable, mapper, opt = {}) {
             }
         });
         if (errors.length) {
-            throw new AggregatedError(errors, ret);
+            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
         }
         return ret;
     }
@@ -122,7 +121,7 @@ export async function pMap(iterable, mapper, opt = {}) {
                     isSettled = true;
                     const r = ret.filter(r => r !== SKIP);
                     if (errors.length) {
-                        reject(new AggregatedError(errors, r));
+                        reject(new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`));
                     }
                     else {
                         resolve(r);

package/dist-esm/string/stringifyAny.js

@@ -1,6 +1,7 @@
 import { _isErrorObject, _isHttpErrorObject, _isHttpErrorResponse } from '../error/error.util';
 import { _jsonParseIfPossible } from './json.util';
 import { _safeJsonStringify } from './safeJsonStringify';
+const supportsAggregateError = typeof globalThis.AggregateError === 'function';
 let globalStringifyFunction = _safeJsonStringify;
 /**
  * Allows to set Global "stringifyFunction" that will be used to "pretty-print" objects
@@ -55,6 +56,7 @@ export function _stringifyAny(obj, opt = {}) {
         return _stringifyAny(obj.error, opt);
     }
     if (obj instanceof Error || _isErrorObject(obj)) {
+        const { includeErrorCause = true } = opt;
         //
         // Error or ErrorObject
         //
@@ -63,7 +65,7 @@ export function _stringifyAny(obj, opt = {}) {
         // if (obj?.name === 'Error') {
         //   s = obj.message
         // }
-        s = [obj.name, obj.message].join(': ');
+        s = [obj.name, obj.message].filter(Boolean).join(': ');
         if (opt.includeErrorStack && obj.stack) {
             // Here we're using the previously-generated "title line" (e.g "Error: some_message"),
             // concatenating it with the Stack (but without the title line of the Stack)
@@ -88,6 +90,16 @@ export function _stringifyAny(obj, opt = {}) {
             // Error that has no `data`, but has `code` property
             s = [s, `code: ${obj.code}`].join('\n');
         }
+        if (supportsAggregateError && obj instanceof AggregateError && obj.errors.length) {
+            s = [
+                s,
+                `${obj.errors.length} error(s):`,
+                ...obj.errors.map((err, i) => `${i + 1}. ${_stringifyAny(err, opt)}`),
+            ].join('\n');
+        }
+        if (obj.cause && includeErrorCause) {
+            s = s + '\ncaused by: ' + _stringifyAny(obj.cause, opt);
+        }
     }
     else if (typeof obj === 'string') {
         //

package/package.json

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

package/src/decorators/asyncMemo.decorator.ts

@@ -11,12 +11,12 @@ export interface AsyncMemoOptions {
    * Function that creates an instance of `MemoCache`.
    * e.g LRUMemoCache from `@naturalcycles/nodejs-lib`.
    */
-  cacheFactory?(): AsyncMemoCache
+  cacheFactory?: () => AsyncMemoCache
 
   /**
    * Provide a custom implementation of CacheKey function.
    */
-  cacheKeyFn?(args: any[]): any
+  cacheKeyFn?: (args: any[]) => any
 
   /**
    * Default true.

package/src/decorators/createPromiseDecorator.ts

@@ -7,14 +7,14 @@ export interface PromiseDecoratorCfg<RES = any, PARAMS = any> {
    * Called BEFORE the original function.
    * If Promise is returned - it will be awaited.
    */
-  beforeFn?(r: PromiseDecoratorResp<PARAMS>): void | Promise<void>
+  beforeFn?: (r: PromiseDecoratorResp<PARAMS>) => void | Promise<void>
 
   /**
    * Called just AFTER the original function.
    * The output of this hook will be passed further,
    * so, pay attention to pass through (or modify) the result.
    */
-  thenFn?(r: PromiseDecoratorResp<PARAMS> & { res: RES }): RES
+  thenFn?: (r: PromiseDecoratorResp<PARAMS> & { res: RES }) => RES
 
   /**
    * Called on Promise.reject.
@@ -23,13 +23,13 @@ export interface PromiseDecoratorCfg<RES = any, PARAMS = any> {
    * If `catchFn` is present - it's responsible for handling or re-throwing the error.
    * Whatever `catchFn` returns - passed to the original output.
    */
-  catchFn?(r: PromiseDecoratorResp<PARAMS> & { err: any }): RES
+  catchFn?: (r: PromiseDecoratorResp<PARAMS> & { err: any }) => RES
 
   /**
    * Fires AFTER thenFn / catchFn, like a usual Promise.finally().
    * Doesn't have access to neither res nor err (same as Promise.finally).
    */
-  finallyFn?(r: PromiseDecoratorResp<PARAMS>): any
+  finallyFn?: (r: PromiseDecoratorResp<PARAMS>) => any
 }
 
 export interface PromiseDecoratorResp<PARAMS> {

package/src/decorators/debounce.ts

@@ -1,8 +1,8 @@
 import type { AnyFunction } from '../types'
 
 export interface Cancelable {
-  cancel(): void
-  flush(): void
+  cancel: () => void
+  flush: () => void
 }
 
 export interface ThrottleOptions {

package/src/decorators/memo.decorator.ts

@@ -11,12 +11,12 @@ export interface MemoOptions {
    * Function that creates an instance of `MemoCache`.
    * e.g LRUMemoCache from `@naturalcycles/nodejs-lib`
    */
-  cacheFactory?(): MemoCache
+  cacheFactory?: () => MemoCache
 
   /**
    * Provide a custom implementation of CacheKey function.
    */
-  cacheKeyFn?(args: any[]): any
+  cacheKeyFn?: (args: any[]) => any
 
   /**
    * Defaults to true.

package/src/decorators/memo.util.ts

@@ -10,15 +10,15 @@ export const jsonMemoSerializer: MemoSerializer = args => {
 }
 
 export interface MemoCache<KEY = any, VALUE = any> {
-  has(k: KEY): boolean
-  get(k: KEY): VALUE | Error | undefined
-  set(k: KEY, v: VALUE | Error): void
+  has: (k: KEY) => boolean
+  get: (k: KEY) => VALUE | Error | undefined
+  set: (k: KEY, v: VALUE | Error) => void
 
   /**
    * Clear is only called when `.dropCache()` is called.
    * Otherwise the Cache is "persistent" (never cleared).
    */
-  clear(): void
+  clear: () => void
 }
 
 export interface AsyncMemoCache<KEY = any, VALUE = any> {
@@ -29,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): Promisable<VALUE | Error | undefined>
-  set(k: KEY, v: VALUE | Error): Promisable<void>
+  get: (k: KEY) => Promisable<VALUE | Error | undefined>
+  set: (k: KEY, v: VALUE | Error) => Promisable<void>
 
   /**
    * Clear is only called when `.dropCache()` is called.
    * Otherwise the Cache is "persistent" (never cleared).
    */
-  clear(): Promisable<void>
+  clear: () => Promisable<void>
 }
 
 // SingleValueMemoCache and ObjectMemoCache are example-only, not used in production code

package/src/error/app.error.ts

@@ -12,7 +12,12 @@ import type { ErrorData } from './error.model'
 export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
   data!: DATA_TYPE
 
-  constructor(message: string, data = {} as DATA_TYPE) {
+  /**
+   * cause here is normalized to be instance of Error
+   */
+  override cause?: Error
+
+  constructor(message: string, data = {} as DATA_TYPE, opt?: ErrorOptions) {
     super(message)
 
     Object.defineProperty(this, 'name', {
@@ -27,6 +32,16 @@ export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
       enumerable: false,
     })
 
+    if (opt?.cause) {
+      Object.defineProperty(this, 'cause', {
+        // I'd love to do _anyToError(opt.cause) here, but it causes circular dep ;(
+        value: opt.cause,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+      })
+    }
+
     // todo: check if it's needed at all!
     // if (Error.captureStackTrace) {
     //   Error.captureStackTrace(this, this.constructor)

package/src/error/assert.ts

@@ -123,8 +123,4 @@ export function _assertTypeOf<T>(v: any, expectedType: string, message?: string)
   }
 }
 
-export class AssertionError extends AppError {
-  constructor(message: string, data = {} as ErrorData) {
-    super(message, data)
-  }
-}
+export class AssertionError extends AppError {}

package/src/error/error.model.ts

@@ -76,6 +76,14 @@ export interface Admin403ErrorData extends HttpErrorData {
   adminPermissionsRequired: string[]
 }
 
+// export interface ErrorLike {
+//   name: string
+//   message: string
+//   stack?: string
+//   data?: any
+//   cause?: any
+// }
+
 /**
  * Portable object that represents Error.
  * Has extendable generic `data` property.
@@ -114,6 +122,8 @@ export interface ErrorObject<DATA_TYPE extends ErrorData = ErrorData> {
    * It's non-optional, to save some null-checks.
    */
   data: DATA_TYPE
+
+  cause?: ErrorObject
 }
 
 /**

package/src/error/error.util.ts

@@ -1,11 +1,4 @@
-import type {
-  ErrorData,
-  ErrorObject,
-  HttpErrorData,
-  HttpErrorResponse,
-  StringifyAnyOptions,
-  Class,
-} from '..'
+import type { ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Class } from '..'
 import { AppError, _jsonParseIfPossible, _stringifyAny } from '..'
 
 /**
@@ -20,7 +13,6 @@ export function _anyToError<ERROR_TYPE extends Error = Error>(
   o: any,
   errorClass: Class<ERROR_TYPE> = Error as any,
   errorData?: ErrorData,
-  opt?: StringifyAnyOptions,
 ): ERROR_TYPE {
   let e: ERROR_TYPE
 
@@ -29,8 +21,8 @@ export function _anyToError<ERROR_TYPE extends Error = Error>(
   } else {
     // If it's an instance of Error, but ErrorClass is something else (e.g AppError) - it'll be "repacked" into AppError
 
-    const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, {}, opt)
-    e = _errorObjectToError(errorObject, errorClass) as any
+    const errorObject = _anyToErrorObject(o)
+    e = _errorObjectToError(errorObject, errorClass)
   }
 
   if (errorData) {
@@ -52,17 +44,16 @@ export function _anyToError<ERROR_TYPE extends Error = Error>(
 export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   o: any,
   errorData?: Partial<DATA_TYPE>,
-  opt?: StringifyAnyOptions,
 ): ErrorObject<DATA_TYPE> {
   let eo: ErrorObject<DATA_TYPE>
 
   if (o instanceof Error) {
-    eo = _errorToErrorObject<DATA_TYPE>(o, opt?.includeErrorStack ?? true)
+    eo = _errorToErrorObject<DATA_TYPE>(o)
   } else {
     o = _jsonParseIfPossible(o)
 
     if (_isHttpErrorResponse(o)) {
-      eo = o.error as any
+      eo = o.error as ErrorObject<DATA_TYPE>
     } else if (_isErrorObject(o)) {
       eo = o as ErrorObject<DATA_TYPE>
     } else {
@@ -70,10 +61,7 @@ export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
       // so, fair to return `data: {}` in the end
       // Also we're sure it includes no "error name", e.g no `Error: ...`,
       // so, fair to include `name: 'Error'`
-      const message = _stringifyAny(o, {
-        includeErrorData: true, // cause we're returning an ErrorObject, not a stringified error (yet)
-        ...opt,
-      })
+      const message = _stringifyAny(o)
 
       eo = {
         name: 'Error',
@@ -89,27 +77,21 @@ export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
 
 export function _errorToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   e: AppError<DATA_TYPE> | Error,
-  includeErrorStack = true,
 ): ErrorObject<DATA_TYPE> {
   const obj: ErrorObject<DATA_TYPE> = {
     name: e.name,
     message: e.message,
     data: { ...(e as any).data }, // empty by default
+    stack: e.stack,
   }
 
-  if (includeErrorStack) {
-    obj.stack = e.stack
+  if (e.cause) {
+    obj.cause = _anyToErrorObject(e.cause)
   }
 
   return obj
 }
 
-export function _errorObjectToAppError<DATA_TYPE extends ErrorData>(
-  o: ErrorObject<DATA_TYPE>,
-): AppError<DATA_TYPE> {
-  return _errorObjectToError(o, AppError)
-}
-
 export function _errorObjectToError<DATA_TYPE extends ErrorData, ERROR_TYPE extends Error>(
   o: ErrorObject<DATA_TYPE>,
   errorClass: Class<ERROR_TYPE> = Error as any,
@@ -138,6 +120,15 @@ export function _errorObjectToError<DATA_TYPE extends ErrorData, ERROR_TYPE exte
     })
   }
 
+  if (o.cause) {
+    Object.defineProperty(err, 'cause', {
+      value: o.cause,
+      writable: true,
+      configurable: true,
+      enumerable: false,
+    })
+  }
+
   return err
 }
 
@@ -159,10 +150,18 @@ export function _isHttpErrorObject(o: any): o is ErrorObject<HttpErrorData> {
  */
 export function _isErrorObject(o: any): o is ErrorObject {
   return (
-    !!o && typeof o.name === 'string' && typeof o.message === 'string' && typeof o.data === 'object'
+    !!o &&
+    typeof o === 'object' &&
+    typeof o.name === 'string' &&
+    typeof o.message === 'string' &&
+    typeof o.data === 'object'
   )
 }
 
+// export function _isErrorLike(o: any): o is ErrorLike {
+//   return !!o && typeof o === 'object' && typeof o.name === 'string' && typeof o.message === 'string'
+// }
+
 /**
  * Convenience function to safely add properties to Error's `data` object
  * (even if it wasn't previously existing)

package/src/error/errorMode.ts

@@ -10,7 +10,7 @@ export enum ErrorMode {
   THROW_IMMEDIATELY = 'THROW_IMMEDIATELY',
 
   /**
-   * Don't throw on errors, but collect them and throw as AggregatedError in the end.
+   * Don't throw on errors, but collect them and throw as AggregateError in the end.
    */
   THROW_AGGREGATED = 'THROW_AGGREGATED',
 

package/src/error/http.error.ts

@@ -7,7 +7,7 @@ import type { HttpErrorData } from './error.model'
 export class HttpError<
   DATA_TYPE extends HttpErrorData = HttpErrorData,
 > extends AppError<DATA_TYPE> {
-  constructor(message: string, data: DATA_TYPE) {
-    super(message, data)
+  constructor(message: string, data: DATA_TYPE, opt?: ErrorOptions) {
+    super(message, data, opt)
   }
 }

package/src/error/tryCatch.ts

@@ -7,7 +7,7 @@ export interface TryCatchOptions {
    * The value returned from the function will be returned from the wrapped method (!).
    * onError function may be asynchronous.
    */
-  onError?(err: Error): any
+  onError?: (err: Error) => any
 
   /**
    * @default false

package/src/http/fetcher.ts

@@ -219,15 +219,12 @@ export class Fetcher {
                 res.body = text
                 res.body = JSON.parse(text, req.jsonReviver)
               } catch (err) {
+                const { message } = _anyToError(err)
+                res.err = new HttpError([signature, message].join('\n'), {
+                  httpStatusCode: 0,
+                  url: req.url,
+                })
                 res.ok = false
-                res.err = _anyToError(
-                  err,
-                  HttpError,
-                  _filterNullishValues({
-                    httpStatusCode: 0,
-                    url: req.url,
-                  }),
-                )
               }
             } else {
               // Body had a '' (empty string)

package/src/index.ts

@@ -37,7 +37,6 @@ export * from './object/deepEquals'
 export * from './object/object.util'
 export * from './object/sortObject'
 export * from './object/sortObjectDeep'
-export * from './promise/AggregatedError'
 export * from './promise/pDefer'
 export * from './promise/pDelay'
 export * from './promise/pFilter'

package/src/json-schema/jsonSchemaBuilder.ts

@@ -26,7 +26,7 @@ import type {
 /* eslint-disable id-blacklist, @typescript-eslint/explicit-module-boundary-types */
 
 export interface JsonSchemaBuilder<T = unknown> {
-  build(): JsonSchema<T>
+  build: () => JsonSchema<T>
 }
 
 /**

package/src/promise/pDefer.ts

@@ -2,8 +2,8 @@
  * Similar to Deferred object, which is also a promise itself (instead of deferred.promise).
  */
 export interface DeferredPromise<T = void> extends Promise<T> {
-  resolve(a?: T): void
-  reject(e?: Error): void
+  resolve: (a?: T) => void
+  reject: (e?: Error) => void
 }
 
 /* eslint-disable @typescript-eslint/promise-function-async */

package/src/promise/pMap.ts

@@ -9,7 +9,6 @@ Improvements:
 
 import type { AbortableAsyncMapper } from '..'
 import { END, ErrorMode, SKIP } from '..'
-import { AggregatedError } from './AggregatedError'
 
 export interface PMapOptions {
   /**
@@ -93,7 +92,7 @@ export async function pMap<IN, OUT>(
     }
 
     if (errors.length) {
-      throw new AggregatedError(errors, ret)
+      throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
     }
 
     return ret as OUT[]
@@ -115,7 +114,7 @@ export async function pMap<IN, OUT>(
     })
 
     if (errors.length) {
-      throw new AggregatedError(errors, ret)
+      throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`)
     }
 
     return ret as OUT[]
@@ -135,7 +134,7 @@ export async function pMap<IN, OUT>(
           isSettled = true
           const r = ret.filter(r => r !== SKIP) as OUT[]
           if (errors.length) {
-            reject(new AggregatedError(errors, r))
+            reject(new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`))
           } else {
             resolve(r)
           }