@naturalcycles/js-lib 14.142.0 → 14.143.0

package/dist/error/app.error.d.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.
  *
@@ -11,8 +11,8 @@ import type { ErrorData } from './error.model';
 export declare 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
      */
-    cause?: Error;
-    constructor(message: string, data?: DATA_TYPE, opt?: ErrorOptions, name?: string);
+    cause?: ErrorObject;
+    constructor(message: string, data?: DATA_TYPE, cause?: ErrorObject, name?: string);
 }

package/dist/error/app.error.js

@@ -11,7 +11,7 @@ exports.AppError = void 0;
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 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,
@@ -30,10 +30,10 @@ class AppError extends Error {
             configurable: true,
             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/dist/error/assert.d.ts

@@ -1,4 +1,5 @@
-import type { ErrorData } from '..';
+import type { ErrorData, ErrorObject } from '..';
+import { Class } from '..';
 import { AppError } from './app.error';
 /**
  * Evaluates the `condition` (casts it to Boolean).
@@ -31,10 +32,11 @@ export declare function _assertEquals<T>(actual: any, expected: T, message?: str
  * Does DEEP equality via _deepEquals()
  */
 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 _assertIsError<ERR extends Error = Error>(err: any, errorClass?: Class<ERR>): asserts err is ERR;
+export declare function _assertIsErrorObject<DATA_TYPE extends ErrorData = ErrorData>(obj: any): asserts obj is ErrorObject<DATA_TYPE>;
 export declare function _assertIsString(v: any, message?: string): asserts v is string;
 export declare function _assertIsNumber(v: any, message?: string): asserts v is number;
 export declare function _assertTypeOf<T>(v: any, expectedType: string, message?: string): asserts v is T;
 export declare class AssertionError extends AppError {
-    constructor(message: string, data?: {}, opt?: ErrorOptions);
+    constructor(message: string, data?: {}, cause?: ErrorObject);
 }

package/dist/error/assert.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssertionError = exports._assertTypeOf = exports._assertIsNumber = exports._assertIsString = exports._assertIsError = exports._assertDeepEquals = exports._assertEquals = exports._assert = void 0;
+exports.AssertionError = exports._assertTypeOf = exports._assertIsNumber = exports._assertIsString = exports._assertIsErrorObject = exports._assertIsError = exports._assertDeepEquals = exports._assertEquals = exports._assert = void 0;
 const __1 = require("..");
 const app_error_1 = require("./app.error");
 /**
@@ -72,15 +72,27 @@ function _assertDeepEquals(actual, expected, message, errorData) {
     }
 }
 exports._assertDeepEquals = _assertDeepEquals;
-function _assertIsError(err, message) {
-    if (!(err instanceof Error)) {
-        const msg = [message || `expected to be instanceof Error`, `actual typeof: ${typeof err}`].join('\n');
+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,
         });
     }
 }
 exports._assertIsError = _assertIsError;
+function _assertIsErrorObject(obj) {
+    if (!(0, __1._isErrorObject)(obj)) {
+        const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n');
+        throw new AssertionError(msg, {
+            userFriendly: true,
+        });
+    }
+}
+exports._assertIsErrorObject = _assertIsErrorObject;
 function _assertIsString(v, message) {
     _assertTypeOf(v, 'string', message);
 }
@@ -103,8 +115,8 @@ function _assertTypeOf(v, expectedType, message) {
 }
 exports._assertTypeOf = _assertTypeOf;
 class AssertionError extends app_error_1.AppError {
-    constructor(message, data = {}, opt) {
-        super(message, data, opt, 'AssertionError');
+    constructor(message, data = {}, cause) {
+        super(message, data, cause, 'AssertionError');
     }
 }
 exports.AssertionError = AssertionError;

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

@@ -1,3 +1,5 @@
+import { HttpMethod, HttpStatusCode } from '../http/http.model';
+import { NumberOfMilliseconds } from '../types';
 /**
  * Extendable payload object to transfer custom additional data with AppError.
  */
@@ -18,8 +20,15 @@ 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.
@@ -31,42 +40,52 @@ 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;
     /**
      * Can be used by error-reporting tools (e.g Sentry).
      * If fingerprint is defined - it'll be used INSTEAD of default fingerprint of a tool.
      * 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.
+     * 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;
-}
-export interface HttpErrorData extends ErrorData {
+    backendResponseStatusCode?: HttpStatusCode;
     /**
-     * @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.
      */
+    adminAuthRequired?: boolean;
     /**
-     * Set to true when the error was thrown after response headers were sent.
+     * Used in e.g http 403 error.
      */
-    headersSent?: boolean;
-}
-export interface Admin401ErrorData extends HttpErrorData {
-    adminAuthRequired: true;
+    adminPermissionsRequired?: string[];
+    /**
+     * 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;
 }
 /**
  * Portable object that represents Error.
@@ -78,6 +97,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> {
     /**
@@ -102,8 +123,10 @@ export interface ErrorObject<DATA_TYPE extends ErrorData = ErrorData> {
     cause?: ErrorObject;
 }
 /**
- * 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/dist/error/error.util.d.ts

@@ -1,4 +1,4 @@
-import type { ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Class } from '..';
+import type { ErrorData, ErrorObject, BackendErrorResponseObject, Class, HttpRequestErrorData } from '..';
 import { AppError } from '..';
 /**
  * Useful to ensure that error in `catch (err) { ... }`
@@ -18,12 +18,12 @@ export declare function _anyToError<ERROR_TYPE extends Error = Error>(o: any, er
 export declare function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(o: any, errorData?: Partial<DATA_TYPE>): ErrorObject<DATA_TYPE>;
 export declare function _errorToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(e: AppError<DATA_TYPE> | Error): ErrorObject<DATA_TYPE>;
 export declare function _errorObjectToError<DATA_TYPE extends ErrorData, ERROR_TYPE extends Error>(o: ErrorObject<DATA_TYPE>, errorClass?: Class<ERROR_TYPE>): ERROR_TYPE;
-export declare function _isHttpErrorResponse(o: any): o is HttpErrorResponse;
-export declare function _isHttpErrorObject(o: any): o is ErrorObject<HttpErrorData>;
+export declare function _isBackendErrorResponseObject(o: any): o is BackendErrorResponseObject;
+export declare function _isHttpRequestErrorObject(o: any): o is ErrorObject<HttpRequestErrorData>;
 /**
  * Note: any instance of AppError is also automatically an ErrorObject
  */
-export declare function _isErrorObject(o: any): o is ErrorObject;
+export declare function _isErrorObject<DATA_TYPE extends ErrorData = ErrorData>(o: any): o is ErrorObject<DATA_TYPE>;
 /**
  * Convenience function to safely add properties to Error's `data` object
  * (even if it wasn't previously existing)

package/dist/error/error.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._errorDataAppend = exports._isErrorObject = exports._isHttpErrorObject = exports._isHttpErrorResponse = exports._errorObjectToError = exports._errorToErrorObject = exports._anyToErrorObject = exports._anyToError = void 0;
+exports._errorDataAppend = exports._isErrorObject = exports._isHttpRequestErrorObject = exports._isBackendErrorResponseObject = exports._errorObjectToError = exports._errorToErrorObject = exports._anyToErrorObject = exports._anyToError = void 0;
 const __1 = require("..");
 /**
  * Useful to ensure that error in `catch (err) { ... }`
@@ -43,7 +43,7 @@ function _anyToErrorObject(o, errorData) {
     }
     else {
         o = (0, __1._jsonParseIfPossible)(o);
-        if (_isHttpErrorResponse(o)) {
+        if (_isBackendErrorResponseObject(o)) {
             eo = o.error;
         }
         else if (_isErrorObject(o)) {
@@ -117,17 +117,14 @@ function _errorObjectToError(o, errorClass = Error) {
     return err;
 }
 exports._errorObjectToError = _errorObjectToError;
-function _isHttpErrorResponse(o) {
-    return _isHttpErrorObject(o?.error);
+function _isBackendErrorResponseObject(o) {
+    return _isErrorObject(o?.error);
 }
-exports._isHttpErrorResponse = _isHttpErrorResponse;
-function _isHttpErrorObject(o) {
-    return (!!o &&
-        typeof o.name === 'string' &&
-        typeof o.message === 'string' &&
-        typeof o.data?.httpStatusCode === 'number');
+exports._isBackendErrorResponseObject = _isBackendErrorResponseObject;
+function _isHttpRequestErrorObject(o) {
+    return !!o && o.name === 'HttpRequestError' && typeof o.data?.requestUrl === 'string';
 }
-exports._isHttpErrorObject = _isHttpErrorObject;
+exports._isHttpRequestErrorObject = _isHttpRequestErrorObject;
 /**
  * Note: any instance of AppError is also automatically an ErrorObject
  */

package/dist/error/httpRequestError.d.ts

@@ -0,0 +1,22 @@
+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 declare class HttpRequestError extends AppError<HttpRequestErrorData> {
+    constructor(message: string, data: HttpRequestErrorData, cause?: ErrorObject);
+}

package/dist/error/httpRequestError.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestError = void 0;
+const app_error_1 = require("./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).
+ */
+class HttpRequestError extends app_error_1.AppError {
+    constructor(message, data, cause) {
+        super(message, data, cause, 'HttpRequestError');
+    }
+}
+exports.HttpRequestError = HttpRequestError;

package/dist/error/jsonParseError.d.ts

@@ -0,0 +1,11 @@
+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 declare class JsonParseError extends AppError<JsonParseErrorData> {
+    constructor(data: JsonParseErrorData, cause?: ErrorObject);
+}

package/dist/error/jsonParseError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonParseError = void 0;
+const string_util_1 = require("../string/string.util");
+const app_error_1 = require("./app.error");
+class JsonParseError extends app_error_1.AppError {
+    constructor(data, cause) {
+        super(['Failed to parse', data?.text && (0, string_util_1._truncateMiddle)(data.text, 200)].filter(Boolean).join(': '), data, cause, 'JsonParseError');
+    }
+}
+exports.JsonParseError = JsonParseError;

package/dist/error/try.js

@@ -55,7 +55,7 @@ exports.pTry = pTry;
  */
 class UnexpectedPassError extends app_error_1.AppError {
     constructor() {
-        super('expected error was not thrown');
+        super('expected error was not thrown', {}, undefined, 'UnexpectedPassError');
     }
 }
 exports.UnexpectedPassError = UnexpectedPassError;

package/dist/http/fetcher.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFetcher = exports.Fetcher = void 0;
 const env_1 = require("../env");
 const error_util_1 = require("../error/error.util");
-const http_error_1 = require("../error/http.error");
+const httpRequestError_1 = require("../error/httpRequestError");
 const number_util_1 = require("../number/number.util");
 const object_util_1 = require("../object/object.util");
 const pDelay_1 = require("../promise/pDelay");
@@ -148,7 +148,7 @@ class Fetcher {
             }
             else {
                 // !res.ok
-                await this.onNotOkResponse(res, timeout);
+                await this.onNotOkResponse(res, started, timeout);
             }
         }
         for await (const hook of this.cfg.hooks.afterResponse || []) {
@@ -165,15 +165,21 @@ class Fetcher {
                 if (text) {
                     try {
                         res.body = text;
-                        res.body = JSON.parse(text, req.jsonReviver);
+                        res.body = (0, json_util_1._jsonParse)(text, req.jsonReviver);
                     }
                     catch (err) {
-                        const { message } = (0, error_util_1._anyToError)(err);
-                        res.err = new http_error_1.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 = (0, error_util_1._anyToError)(err);
                         res.ok = false;
+                        return await this.onNotOkResponse(res, started, timeout);
                     }
                 }
                 else {
@@ -222,37 +228,34 @@ class Fetcher {
     async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
-    async onNotOkResponse(res, timeout) {
+    async onNotOkResponse(res, started, timeout) {
         clearTimeout(timeout);
-        let errObj;
-        if (res.fetchResponse) {
-            const body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
-            errObj = (0, error_util_1._anyToErrorObject)(body);
-        }
-        else if (res.err) {
-            errObj = (0, error_util_1._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 = (0, error_util_1._errorToErrorObject)(res.err);
         }
-        else {
-            errObj = {};
+        else if (res.fetchResponse) {
+            const body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
+            if (body) {
+                cause = (0, error_util_1._anyToErrorObject)(body);
+            }
         }
-        const originalMessage = errObj.message;
-        errObj.message = [
-            [res.fetchResponse?.status, res.signature].filter(Boolean).join(' '),
-            originalMessage,
-        ]
-            .filter(Boolean)
-            .join('\n');
-        res.err = new http_error_1.HttpError(errObj.message, (0, object_util_1._filterNullishValues)({
-            ...errObj.data,
-            originalMessage,
-            httpStatusCode: res.fetchResponse?.status || 0,
+        const message = [res.fetchResponse?.status, res.signature].filter(Boolean).join(' ');
+        res.err = new httpRequestError_1.HttpRequestError(message, (0, object_util_1._filterNullishValues)({
+            responseStatusCode: res.fetchResponse?.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/http/http.model.d.ts

@@ -1,3 +1,7 @@
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD';
 export type HttpStatusFamily = 5 | 4 | 3 | 2 | 1;
+/**
+ * Number, representing a valid Http status code (e.g 401, 500, etc)
+ */
+export type HttpStatusCode = number;
 export declare const HTTP_METHODS: HttpMethod[];

package/dist/index.d.ts

@@ -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/index.js

@@ -24,9 +24,10 @@ tslib_1.__exportStar(require("./enum.util"), exports);
 tslib_1.__exportStar(require("./error/error.model"), exports);
 tslib_1.__exportStar(require("./error/error.util"), exports);
 tslib_1.__exportStar(require("./error/errorMode"), exports);
-tslib_1.__exportStar(require("./error/http.error"), exports);
+tslib_1.__exportStar(require("./error/httpRequestError"), exports);
 tslib_1.__exportStar(require("./error/try"), exports);
 tslib_1.__exportStar(require("./error/tryCatch"), exports);
+tslib_1.__exportStar(require("./error/jsonParseError"), exports);
 tslib_1.__exportStar(require("./json-schema/from-data/generateJsonSchemaFromData"), exports);
 tslib_1.__exportStar(require("./json-schema/jsonSchema.cnst"), exports);
 tslib_1.__exportStar(require("./json-schema/jsonSchema.model"), exports);

package/dist/promise/pTimeout.d.ts

@@ -1,8 +1,8 @@
 import { AppError } from '../error/app.error';
-import type { ErrorData } from '../error/error.model';
+import type { ErrorData, ErrorObject } from '../error/error.model';
 import type { AnyAsyncFunction } from '../types';
 export declare class TimeoutError extends AppError {
-    constructor(message: string, data?: {}, opt?: ErrorOptions);
+    constructor(message: string, data?: {}, cause?: ErrorObject);
 }
 export interface PTimeoutOptions {
     /**

package/dist/promise/pTimeout.js

@@ -4,8 +4,8 @@ exports.pTimeout = exports.pTimeoutFn = exports.TimeoutError = void 0;
 const app_error_1 = require("../error/app.error");
 const error_util_1 = require("../error/error.util");
 class TimeoutError extends app_error_1.AppError {
-    constructor(message, data = {}, opt) {
-        super(message, data, opt, 'TimeoutError');
+    constructor(message, data = {}, cause) {
+        super(message, data, cause, 'TimeoutError');
     }
 }
 exports.TimeoutError = TimeoutError;

package/dist/string/json.util.d.ts

@@ -1,5 +1,13 @@
+import { Reviver } from '../types';
 /**
  * Attempts to parse object as JSON.
  * Returns original object if JSON parse failed (silently).
  */
-export declare function _jsonParseIfPossible(obj: any, reviver?: (this: any, key: string, value: any) => any): any;
+export declare function _jsonParseIfPossible(obj: any, reviver?: Reviver): any;
+/**
+ * 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 declare function _jsonParse(s: string, reviver?: Reviver): unknown;

package/dist/string/json.util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._jsonParseIfPossible = void 0;
+exports._jsonParse = exports._jsonParseIfPossible = void 0;
+const jsonParseError_1 = require("../error/jsonParseError");
 // const possibleJsonStartTokens = ['{', '[', '"']
 const DETECT_JSON = /^\s*[{["\-\d]/;
 /**
@@ -18,3 +19,20 @@ function _jsonParseIfPossible(obj, reviver) {
     return obj;
 }
 exports._jsonParseIfPossible = _jsonParseIfPossible;
+/**
+ * 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
+ */
+function _jsonParse(s, reviver) {
+    try {
+        return JSON.parse(s, reviver);
+    }
+    catch {
+        throw new jsonParseError_1.JsonParseError({
+            text: s,
+        });
+    }
+}
+exports._jsonParse = _jsonParse;

package/dist/string/stringifyAny.js

@@ -56,7 +56,7 @@ function _stringifyAny(obj, opt = {}) {
     //
     // HttpErrorResponse
     //
-    if ((0, error_util_1._isHttpErrorResponse)(obj)) {
+    if ((0, error_util_1._isBackendErrorResponseObject)(obj)) {
         return _stringifyAny(obj.error, opt);
     }
     if (obj instanceof Error || (0, error_util_1._isErrorObject)(obj)) {
@@ -69,11 +69,11 @@ function _stringifyAny(obj, opt = {}) {
         // if (obj?.name === 'Error') {
         //   s = obj.message
         // }
-        if ((0, error_util_1._isErrorObject)(obj) && (0, error_util_1._isHttpErrorObject)(obj)) {
-            // Printing (0) to avoid ambiguity
-            s = `${obj.name}(${obj.data.httpStatusCode}): ${obj.message}`;
-        }
-        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/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,