@naturalcycles/js-lib 14.141.0 → 14.143.0

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

@@ -8,7 +8,7 @@
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 export class AppError extends Error {
-    constructor(message, data = {}, opt, name) {
+    constructor(message, data = {}, cause, name) {
         super(message);
         Object.defineProperty(this, 'name', {
             value: name || this.constructor.name,
@@ -27,10 +27,10 @@ export class AppError extends Error {
             configurable: true,
             enumerable: false,
         });
-        if (opt === null || opt === void 0 ? void 0 : opt.cause) {
+        if (cause) {
             Object.defineProperty(this, 'cause', {
                 // I'd love to do _anyToError(opt.cause) here, but it causes circular dep ;(
-                value: opt.cause,
+                value: cause,
                 writable: true,
                 configurable: true,
                 enumerable: false,

package/dist-esm/error/assert.js

@@ -1,4 +1,4 @@
-import { _deepEquals, _stringifyAny } from '..';
+import { _deepEquals, _isErrorObject, _stringifyAny } from '..';
 import { AppError } from './app.error';
 /**
  * Evaluates the `condition` (casts it to Boolean).
@@ -57,9 +57,20 @@ export function _assertDeepEquals(actual, expected, message, errorData) {
         throw new AssertionError(msg, Object.assign({ userFriendly: true }, errorData));
     }
 }
-export function _assertIsError(err, message) {
-    if (!(err instanceof Error)) {
-        const msg = [message || `expected to be instanceof Error`, `actual typeof: ${typeof err}`].join('\n');
+export function _assertIsError(err, errorClass = Error) {
+    if (!(err instanceof errorClass)) {
+        const msg = [
+            `expected to be instanceof ${errorClass.name}`,
+            `actual typeof: ${typeof err}`,
+        ].join('\n');
+        throw new AssertionError(msg, {
+            userFriendly: true,
+        });
+    }
+}
+export function _assertIsErrorObject(obj) {
+    if (!_isErrorObject(obj)) {
+        const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n');
         throw new AssertionError(msg, {
             userFriendly: true,
         });
@@ -84,7 +95,7 @@ export function _assertTypeOf(v, expectedType, message) {
     }
 }
 export class AssertionError extends AppError {
-    constructor(message, data = {}, opt) {
-        super(message, data, opt, 'AssertionError');
+    constructor(message, data = {}, cause) {
+        super(message, data, cause, 'AssertionError');
     }
 }

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

@@ -36,7 +36,7 @@ export function _anyToErrorObject(o, errorData) {
     }
     else {
         o = _jsonParseIfPossible(o);
-        if (_isHttpErrorResponse(o)) {
+        if (_isBackendErrorResponseObject(o)) {
             eo = o.error;
         }
         else if (_isErrorObject(o)) {
@@ -107,15 +107,12 @@ export function _errorObjectToError(o, errorClass = Error) {
     }
     return err;
 }
-export function _isHttpErrorResponse(o) {
-    return _isHttpErrorObject(o === null || o === void 0 ? void 0 : o.error);
+export function _isBackendErrorResponseObject(o) {
+    return _isErrorObject(o === null || o === void 0 ? void 0 : o.error);
 }
-export function _isHttpErrorObject(o) {
+export function _isHttpRequestErrorObject(o) {
     var _a;
-    return (!!o &&
-        typeof o.name === 'string' &&
-        typeof o.message === 'string' &&
-        typeof ((_a = o.data) === null || _a === void 0 ? void 0 : _a.httpStatusCode) === 'number');
+    return !!o && o.name === 'HttpRequestError' && typeof ((_a = o.data) === null || _a === void 0 ? void 0 : _a.requestUrl) === 'string';
 }
 /**
  * Note: any instance of AppError is also automatically an ErrorObject

package/dist-esm/error/httpRequestError.js

@@ -0,0 +1,23 @@
+import { AppError } from './app.error';
+/**
+ * Error that is thrown when Http Request was made and returned an error.
+ * Thrown by, for example, Fetcher.
+ *
+ * On the Frontend this Error class represents the error when calling the API,
+ * contains all the necessary request and response information.
+ *
+ * On the Backend, similarly, it represents the error when calling some 3rd-party API
+ * (backend-to-backend call).
+ * On the Backend it often propagates all the way to the Backend error handler,
+ * where it would be wrapped in BackendErrorResponseObject.
+ *
+ * Please note that `ErrorData.backendResponseStatusCode` is NOT exactly the same as
+ * `HttpRequestErrorData.responseStatusCode`.
+ * E.g 3rd-party call may return 401, but our Backend will still wrap it into an 500 error
+ * (by default).
+ */
+export class HttpRequestError extends AppError {
+    constructor(message, data, cause) {
+        super(message, data, cause, 'HttpRequestError');
+    }
+}

package/dist-esm/error/jsonParseError.js

@@ -0,0 +1,7 @@
+import { _truncateMiddle } from '../string/string.util';
+import { AppError } from './app.error';
+export class JsonParseError extends AppError {
+    constructor(data, cause) {
+        super(['Failed to parse', (data === null || data === void 0 ? void 0 : data.text) && _truncateMiddle(data.text, 200)].filter(Boolean).join(': '), data, cause, 'JsonParseError');
+    }
+}

package/dist-esm/error/try.js

@@ -50,7 +50,7 @@ export async function pTry(promise) {
  */
 export class UnexpectedPassError extends AppError {
     constructor() {
-        super('expected error was not thrown');
+        super('expected error was not thrown', {}, undefined, 'UnexpectedPassError');
     }
 }
 /**

package/dist-esm/http/fetcher.js

@@ -2,11 +2,11 @@
 import { __asyncValues } from "tslib";
 import { isServerSide } from '../env';
 import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util';
-import { HttpError } from '../error/http.error';
+import { HttpRequestError } from '../error/httpRequestError';
 import { _clamp } from '../number/number.util';
 import { _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, } from '../object/object.util';
 import { pDelay } from '../promise/pDelay';
-import { _jsonParseIfPossible } from '../string/json.util';
+import { _jsonParse, _jsonParseIfPossible } from '../string/json.util';
 import { _since } from '../time/time.util';
 import { HTTP_METHODS } from './http.model';
 const defRetryOptions = {
@@ -156,7 +156,7 @@ export class Fetcher {
             }
             else {
                 // !res.ok
-                await this.onNotOkResponse(res, timeout);
+                await this.onNotOkResponse(res, started, timeout);
             }
         }
         try {
@@ -190,15 +190,21 @@ export class Fetcher {
                 if (text) {
                     try {
                         res.body = text;
-                        res.body = JSON.parse(text, req.jsonReviver);
+                        res.body = _jsonParse(text, req.jsonReviver);
                     }
                     catch (err) {
-                        const { message } = _anyToError(err);
-                        res.err = new HttpError([res.signature, message].join('\n'), {
-                            httpStatusCode: 0,
-                            url: req.url,
-                        });
+                        // Error while parsing json
+                        // res.err = _anyToError(err, HttpRequestError, {
+                        //   requestUrl: res.req.url,
+                        //   requestBaseUrl: this.cfg.baseUrl,
+                        //   requestMethod: res.req.init.method,
+                        //   requestSignature: res.signature,
+                        //   requestDuration: Date.now() - started,
+                        //   responseStatusCode: res.fetchResponse.status,
+                        // } satisfies HttpRequestErrorData)
+                        res.err = _anyToError(err);
                         res.ok = false;
+                        return await this.onNotOkResponse(res, started, timeout);
                     }
                 }
                 else {
@@ -247,33 +253,35 @@ export class Fetcher {
     async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
-    async onNotOkResponse(res, timeout) {
+    async onNotOkResponse(res, started, timeout) {
         var _a, _b;
         clearTimeout(timeout);
-        let errObj;
-        if (res.fetchResponse) {
-            const body = _jsonParseIfPossible(await res.fetchResponse.text());
-            errObj = _anyToErrorObject(body);
-        }
-        else if (res.err) {
-            errObj = _errorToErrorObject(res.err);
+        let cause;
+        if (res.err) {
+            // This is only possible on JSON.parse error (or CORS error!)
+            // This check should go first, to avoid calling .text() twice (which will fail)
+            cause = _errorToErrorObject(res.err);
         }
-        else {
-            errObj = {};
+        else if (res.fetchResponse) {
+            const body = _jsonParseIfPossible(await res.fetchResponse.text());
+            if (body) {
+                cause = _anyToErrorObject(body);
+            }
         }
-        const originalMessage = errObj.message;
-        errObj.message = [
-            [(_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status, res.signature].filter(Boolean).join(' '),
-            originalMessage,
-        ]
-            .filter(Boolean)
-            .join('\n');
-        res.err = new HttpError(errObj.message, _filterNullishValues(Object.assign(Object.assign({}, errObj.data), { originalMessage, httpStatusCode: ((_b = res.fetchResponse) === null || _b === void 0 ? void 0 : _b.status) || 0, 
+        const message = [(_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status, res.signature].filter(Boolean).join(' ');
+        res.err = new HttpRequestError(message, _filterNullishValues({
+            responseStatusCode: ((_b = res.fetchResponse) === null || _b === void 0 ? void 0 : _b.status) || 0,
             // These properties are provided to be used in e.g custom Sentry error grouping
             // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
             // Enabled, cause `data` is not printed by default when error is HttpError
             // method: req.method,
-            url: res.req.url })));
+            // tryCount: req.tryCount,
+            requestUrl: res.req.url,
+            requestBaseUrl: this.cfg.baseUrl || null,
+            requestMethod: res.req.init.method,
+            requestSignature: res.signature,
+            requestDuration: Date.now() - started,
+        }), cause);
         await this.processRetry(res);
     }
     async processRetry(res) {

package/dist-esm/index.js

@@ -20,9 +20,10 @@ export * from './enum.util';
 export * from './error/error.model';
 export * from './error/error.util';
 export * from './error/errorMode';
-export * from './error/http.error';
+export * from './error/httpRequestError';
 export * from './error/try';
 export * from './error/tryCatch';
+export * from './error/jsonParseError';
 export * from './json-schema/from-data/generateJsonSchemaFromData';
 export * from './json-schema/jsonSchema.cnst';
 export * from './json-schema/jsonSchema.model';

package/dist-esm/promise/pTimeout.js

@@ -1,8 +1,8 @@
 import { AppError } from '../error/app.error';
 import { _errorDataAppend } from '../error/error.util';
 export class TimeoutError extends AppError {
-    constructor(message, data = {}, opt) {
-        super(message, data, opt, 'TimeoutError');
+    constructor(message, data = {}, cause) {
+        super(message, data, cause, 'TimeoutError');
     }
 }
 /**

package/dist-esm/string/json.util.js

@@ -1,3 +1,4 @@
+import { JsonParseError } from '../error/jsonParseError';
 // const possibleJsonStartTokens = ['{', '[', '"']
 const DETECT_JSON = /^\s*[{["\-\d]/;
 /**
@@ -14,3 +15,19 @@ export function _jsonParseIfPossible(obj, reviver) {
     }
     return obj;
 }
+/**
+ * Same as JSON.parse, but throws JsonParseError:
+ *
+ * 1. It's message includes a piece of source text (truncated)
+ * 2. It's data.text contains full source text
+ */
+export function _jsonParse(s, reviver) {
+    try {
+        return JSON.parse(s, reviver);
+    }
+    catch (_a) {
+        throw new JsonParseError({
+            text: s,
+        });
+    }
+}

package/dist-esm/string/stringifyAny.js

@@ -1,4 +1,4 @@
-import { _isErrorObject, _isHttpErrorObject, _isHttpErrorResponse } from '../error/error.util';
+import { _isErrorObject, _isBackendErrorResponseObject } from '../error/error.util';
 import { _jsonParseIfPossible } from './json.util';
 import { _safeJsonStringify } from './safeJsonStringify';
 const supportsAggregateError = typeof globalThis.AggregateError === 'function';
@@ -52,7 +52,7 @@ export function _stringifyAny(obj, opt = {}) {
     //
     // HttpErrorResponse
     //
-    if (_isHttpErrorResponse(obj)) {
+    if (_isBackendErrorResponseObject(obj)) {
         return _stringifyAny(obj.error, opt);
     }
     if (obj instanceof Error || _isErrorObject(obj)) {
@@ -65,11 +65,11 @@ export function _stringifyAny(obj, opt = {}) {
         // if (obj?.name === 'Error') {
         //   s = obj.message
         // }
-        if (_isErrorObject(obj) && _isHttpErrorObject(obj)) {
-            // Printing (0) to avoid ambiguity
-            s = `${obj.name}(${obj.data.httpStatusCode}): ${obj.message}`;
-        }
-        s || (s = [obj.name, obj.message].filter(Boolean).join(': '));
+        // if (_isErrorObject(obj) && _isHttpErrorObject(obj)) {
+        //   // Printing (0) to avoid ambiguity
+        //   s = `${obj.name}(${obj.data.httpStatusCode}): ${obj.message}`
+        // }
+        s = [obj.name, obj.message].filter(Boolean).join(': ');
         if (typeof obj.code === 'string') {
             // Error that has no `data`, but has `code` property
             s += `\ncode: ${obj.code}`;

package/package.json

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

package/src/error/app.error.ts

@@ -1,4 +1,4 @@
-import type { ErrorData } from './error.model'
+import type { ErrorData, ErrorObject } from './error.model'
 
 /**
  * Base class for all our (not system) errors.
@@ -13,11 +13,11 @@ export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
   data!: DATA_TYPE
 
   /**
-   * cause here is normalized to be instance of Error
+   * cause here is normalized to be an ErrorObject
    */
-  override cause?: Error
+  override cause?: ErrorObject
 
-  constructor(message: string, data = {} as DATA_TYPE, opt?: ErrorOptions, name?: string) {
+  constructor(message: string, data = {} as DATA_TYPE, cause?: ErrorObject, name?: string) {
     super(message)
 
     Object.defineProperty(this, 'name', {
@@ -40,10 +40,10 @@ export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
       enumerable: false,
     })
 
-    if (opt?.cause) {
+    if (cause) {
       Object.defineProperty(this, 'cause', {
         // I'd love to do _anyToError(opt.cause) here, but it causes circular dep ;(
-        value: opt.cause,
+        value: cause,
         writable: true,
         configurable: true,
         enumerable: false,

package/src/error/assert.ts

@@ -1,5 +1,5 @@
-import type { ErrorData } from '..'
-import { _deepEquals, _stringifyAny } from '..'
+import type { ErrorData, ErrorObject } from '..'
+import { _deepEquals, _isErrorObject, _stringifyAny, Class } from '..'
 import { AppError } from './app.error'
 
 /**
@@ -88,12 +88,25 @@ export function _assertDeepEquals<T>(
 
 export function _assertIsError<ERR extends Error = Error>(
   err: any,
-  message?: string,
+  errorClass: Class<ERR> = Error as any,
 ): asserts err is ERR {
-  if (!(err instanceof Error)) {
-    const msg = [message || `expected to be instanceof Error`, `actual typeof: ${typeof err}`].join(
-      '\n',
-    )
+  if (!(err instanceof errorClass)) {
+    const msg = [
+      `expected to be instanceof ${errorClass.name}`,
+      `actual typeof: ${typeof err}`,
+    ].join('\n')
+
+    throw new AssertionError(msg, {
+      userFriendly: true,
+    })
+  }
+}
+
+export function _assertIsErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
+  obj: any,
+): asserts obj is ErrorObject<DATA_TYPE> {
+  if (!_isErrorObject(obj)) {
+    const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n')
 
     throw new AssertionError(msg, {
       userFriendly: true,
@@ -124,7 +137,7 @@ export function _assertTypeOf<T>(v: any, expectedType: string, message?: string)
 }
 
 export class AssertionError extends AppError {
-  constructor(message: string, data = {}, opt?: ErrorOptions) {
-    super(message, data, opt, 'AssertionError')
+  constructor(message: string, data = {}, cause?: ErrorObject) {
+    super(message, data, cause, 'AssertionError')
   }
 }

package/src/error/error.model.ts

@@ -1,3 +1,6 @@
+import { HttpMethod, HttpStatusCode } from '../http/http.model'
+import { NumberOfMilliseconds } from '../types'
+
 /**
  * Extendable payload object to transfer custom additional data with AppError.
  */
@@ -21,9 +24,17 @@ export interface ErrorData {
   /**
    * Set to true to force reporting this error (e.g to Sentry).
    * Useful to be able to force-report e.g a 4xx error, which by default wouldn't be reported.
+   * Set to false to force not-reporting it.
    */
   report?: boolean
 
+  /**
+   * Set to true or false to control error reporting on the Client-side.
+   * It works as in indication/hint, not a guarantee,
+   * because Client-side still need to manually check and respect this property.
+   */
+  reportClientSide?: boolean
+
   /**
    * If defined - used by SentrySharedService in backend-lib.
    * Allows to report only X% of errors of this type.
@@ -36,7 +47,8 @@ export interface ErrorData {
    * (e.g frontend-lib adds a method, url, etc for all the errors)
    * `originalMessage` is used to preserve the original `error.message` as it came from the backend.
    */
-  originalMessage?: string
+  // originalMessage?: string
+  // use .cause.message instead
 
   /**
    * Can be used by error-reporting tools (e.g Sentry).
@@ -45,42 +57,51 @@ export interface ErrorData {
    */
   fingerprint?: string[]
 
-  httpStatusCode?: number
-
   /**
-   * Open-ended.
+   * Set when throwing an error from your backend code, to indicate desired http status code.
+   * e.g throw new AppError('oj', { backendResponseStatusCode: 401 })
    */
-  [k: string]: any
-}
+  backendResponseStatusCode?: HttpStatusCode
 
-export interface HttpErrorData extends ErrorData {
   /**
-   * @default 500
+   * Set to true when the error was thrown after response headers were sent.
    */
-  httpStatusCode: number
+  headersSent?: boolean
 
   /**
-   * @example
-   *
-   * GET /api/some-endpoint
+   * Used in e.g http 401 error.
    */
-  // endpoint?: string
+  adminAuthRequired?: boolean
 
   /**
-   * Set to true when the error was thrown after response headers were sent.
+   * Used in e.g http 403 error.
    */
-  headersSent?: boolean
-}
+  adminPermissionsRequired?: string[]
 
-export interface Admin401ErrorData extends HttpErrorData {
-  adminAuthRequired: true
+  /**
+   * Open-ended.
+   */
+  [k: string]: any
 }
 
-export interface Admin403ErrorData extends HttpErrorData {
+export interface HttpRequestErrorData extends ErrorData {
+  requestUrl: string
+  requestBaseUrl?: string
+  requestMethod: HttpMethod
   /**
-   * Returns non-empty array.
+   * Conveniently combines Method and Url, respects `logWithSearchParams` (and similar) configuration.
+   * E.g:
+   * GET /some/url
    */
-  adminPermissionsRequired: string[]
+  requestSignature: string
+  /**
+   * Can be set to 0 if request "failed to start" or "failed to reach the server".
+   */
+  requestDuration: NumberOfMilliseconds
+  /**
+   * 0 is used for edge cases when e.g it failed to reach the server.
+   */
+  responseStatusCode: HttpStatusCode
 }
 
 // export interface ErrorLike {
@@ -101,6 +122,8 @@ export interface Admin403ErrorData extends HttpErrorData {
  * Cannot contain any properties that stock Error doesn't have, otherwise
  * it will be hard to transform it to ErrorObject.
  * Everything "extra" should go under `data`.
+ *
+ * Instance of AppError class should satisfy ErrorObject interface.
  */
 export interface ErrorObject<DATA_TYPE extends ErrorData = ErrorData> {
   /**
@@ -134,8 +157,10 @@ export interface ErrorObject<DATA_TYPE extends ErrorData = ErrorData> {
 }
 
 /**
- * JSON HTTP response from the Backend that represents "Error".
+ * JSON HTTP response object from the Backend that represents "Error".
+ * Assumption is that if JSON response "looks like this" - it's safe to print it in a custom way.
+ * Otherwise - it'll be printed in a generic way.
  */
-export interface HttpErrorResponse<DATA_TYPE extends HttpErrorData = HttpErrorData> {
+export interface BackendErrorResponseObject<DATA_TYPE extends ErrorData = ErrorData> {
   error: ErrorObject<DATA_TYPE>
 }

package/src/error/error.util.ts

@@ -1,4 +1,10 @@
-import type { ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Class } from '..'
+import type {
+  ErrorData,
+  ErrorObject,
+  BackendErrorResponseObject,
+  Class,
+  HttpRequestErrorData,
+} from '..'
 import { AppError, _jsonParseIfPossible, _stringifyAny } from '..'
 
 /**
@@ -52,7 +58,7 @@ export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   } else {
     o = _jsonParseIfPossible(o)
 
-    if (_isHttpErrorResponse(o)) {
+    if (_isBackendErrorResponseObject(o)) {
       eo = o.error as ErrorObject<DATA_TYPE>
     } else if (_isErrorObject(o)) {
       eo = o as ErrorObject<DATA_TYPE>
@@ -139,23 +145,20 @@ export function _errorObjectToError<DATA_TYPE extends ErrorData, ERROR_TYPE exte
   return err
 }
 
-export function _isHttpErrorResponse(o: any): o is HttpErrorResponse {
-  return _isHttpErrorObject(o?.error)
+export function _isBackendErrorResponseObject(o: any): o is BackendErrorResponseObject {
+  return _isErrorObject(o?.error)
 }
 
-export function _isHttpErrorObject(o: any): o is ErrorObject<HttpErrorData> {
-  return (
-    !!o &&
-    typeof o.name === 'string' &&
-    typeof o.message === 'string' &&
-    typeof o.data?.httpStatusCode === 'number'
-  )
+export function _isHttpRequestErrorObject(o: any): o is ErrorObject<HttpRequestErrorData> {
+  return !!o && o.name === 'HttpRequestError' && typeof o.data?.requestUrl === 'string'
 }
 
 /**
  * Note: any instance of AppError is also automatically an ErrorObject
  */
-export function _isErrorObject(o: any): o is ErrorObject {
+export function _isErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
+  o: any,
+): o is ErrorObject<DATA_TYPE> {
   return (
     !!o &&
     typeof o === 'object' &&

package/src/error/httpRequestError.ts

@@ -0,0 +1,25 @@
+import { AppError } from './app.error'
+import type { ErrorObject, HttpRequestErrorData } from './error.model'
+
+/**
+ * Error that is thrown when Http Request was made and returned an error.
+ * Thrown by, for example, Fetcher.
+ *
+ * On the Frontend this Error class represents the error when calling the API,
+ * contains all the necessary request and response information.
+ *
+ * On the Backend, similarly, it represents the error when calling some 3rd-party API
+ * (backend-to-backend call).
+ * On the Backend it often propagates all the way to the Backend error handler,
+ * where it would be wrapped in BackendErrorResponseObject.
+ *
+ * Please note that `ErrorData.backendResponseStatusCode` is NOT exactly the same as
+ * `HttpRequestErrorData.responseStatusCode`.
+ * E.g 3rd-party call may return 401, but our Backend will still wrap it into an 500 error
+ * (by default).
+ */
+export class HttpRequestError extends AppError<HttpRequestErrorData> {
+  constructor(message: string, data: HttpRequestErrorData, cause?: ErrorObject) {
+    super(message, data, cause, 'HttpRequestError')
+  }
+}

package/src/error/jsonParseError.ts

@@ -0,0 +1,21 @@
+import { _truncateMiddle } from '../string/string.util'
+import { AppError } from './app.error'
+import { ErrorData, ErrorObject } from './error.model'
+
+export interface JsonParseErrorData extends ErrorData {
+  /**
+   * Original text that failed to get parsed.
+   */
+  text?: string
+}
+
+export class JsonParseError extends AppError<JsonParseErrorData> {
+  constructor(data: JsonParseErrorData, cause?: ErrorObject) {
+    super(
+      ['Failed to parse', data?.text && _truncateMiddle(data.text, 200)].filter(Boolean).join(': '),
+      data,
+      cause,
+      'JsonParseError',
+    )
+  }
+}

package/src/error/try.ts

@@ -57,7 +57,7 @@ export async function pTry<ERR = Error, RETURN = void>(
  */
 export class UnexpectedPassError extends AppError {
   constructor() {
-    super('expected error was not thrown')
+    super('expected error was not thrown', {}, undefined, 'UnexpectedPassError')
   }
 }