@naturalcycles/js-lib 14.252.0 → 14.252.1

package/dist/error/assert.d.ts

@@ -1,5 +1,4 @@
-import type { ErrorData, ErrorObject } from '..';
-import { Class } from '..';
+import { BackendErrorResponseObject, Class, ErrorData, ErrorObject } from '..';
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.
@@ -40,6 +39,7 @@ export declare function _assertIsError<ERR extends Error = Error>(err: any, erro
  */
 export declare function _assertErrorClassOrRethrow<ERR extends 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 _assertIsBackendErrorResponseObject<DATA_TYPE extends ErrorData = ErrorData>(obj: any): asserts obj is BackendErrorResponseObject<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;

package/dist/error/assert.js

@@ -6,6 +6,7 @@ exports._assertDeepEquals = _assertDeepEquals;
 exports._assertIsError = _assertIsError;
 exports._assertErrorClassOrRethrow = _assertErrorClassOrRethrow;
 exports._assertIsErrorObject = _assertIsErrorObject;
+exports._assertIsBackendErrorResponseObject = _assertIsBackendErrorResponseObject;
 exports._assertIsString = _assertIsString;
 exports._assertIsNumber = _assertIsNumber;
 exports._assertTypeOf = _assertTypeOf;
@@ -89,6 +90,11 @@ function _assertIsErrorObject(obj) {
         throw new __1.AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
     }
 }
+function _assertIsBackendErrorResponseObject(obj) {
+    if (!(0, __1._isBackendErrorResponseObject)(obj)) {
+        throw new __1.AssertionError(`Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`);
+    }
+}
 function _assertIsString(v, message) {
     _assertTypeOf(v, 'string', message);
 }

package/dist/http/fetcher.js

@@ -320,23 +320,32 @@ class Fetcher {
     }
     async onNotOkResponse(res) {
         let cause;
+        // Try to fetch body and attach to res.body
+        // (but don't fail if it doesn't work)
+        if (!res.body && res.fetchResponse) {
+            try {
+                res.body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
+            }
+            catch {
+                // ignore body fetching/parsing errors at this point
+            }
+        }
         if (res.err) {
             // This is only possible on JSON.parse error, or CORS error,
             // or `unexpected redirect`
             // This check should go first, to avoid calling .text() twice (which will fail)
             cause = (0, error_util_1._errorLikeToErrorObject)(res.err);
         }
-        else if (res.fetchResponse) {
-            const body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
-            if (body) {
-                cause = (0, error_util_1._anyToErrorObject)(body);
-            }
+        else if (res.body) {
+            cause = (0, error_util_1._anyToErrorObject)(res.body);
+        }
+        else {
+            cause = {
+                name: 'Error',
+                message: 'Fetch failed',
+                data: {},
+            };
         }
-        cause ||= {
-            name: 'Error',
-            message: 'Fetch failed',
-            data: {},
-        };
         let responseStatusCode = res.fetchResponse?.status || 0;
         if (res.statusFamily === 2) {
             // important to reset responseStatusCode to 0 in this case, as status 2xx can be misleading

package/dist-esm/error/assert.js

@@ -1,4 +1,4 @@
-import { _deepEquals, _isErrorObject, _stringify, AssertionError } from '..';
+import { _deepEquals, _isBackendErrorResponseObject, _isErrorObject, _stringify, AssertionError, } from '..';
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.
@@ -78,6 +78,11 @@ export function _assertIsErrorObject(obj) {
         throw new AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
     }
 }
+export function _assertIsBackendErrorResponseObject(obj) {
+    if (!_isBackendErrorResponseObject(obj)) {
+        throw new AssertionError(`Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`);
+    }
+}
 export function _assertIsString(v, message) {
     _assertTypeOf(v, 'string', message);
 }

package/dist-esm/http/fetcher.js

@@ -312,23 +312,32 @@ export class Fetcher {
     }
     async onNotOkResponse(res) {
         let cause;
+        // Try to fetch body and attach to res.body
+        // (but don't fail if it doesn't work)
+        if (!res.body && res.fetchResponse) {
+            try {
+                res.body = _jsonParseIfPossible(await res.fetchResponse.text());
+            }
+            catch {
+                // ignore body fetching/parsing errors at this point
+            }
+        }
         if (res.err) {
             // This is only possible on JSON.parse error, or CORS error,
             // or `unexpected redirect`
             // This check should go first, to avoid calling .text() twice (which will fail)
             cause = _errorLikeToErrorObject(res.err);
         }
-        else if (res.fetchResponse) {
-            const body = _jsonParseIfPossible(await res.fetchResponse.text());
-            if (body) {
-                cause = _anyToErrorObject(body);
-            }
+        else if (res.body) {
+            cause = _anyToErrorObject(res.body);
+        }
+        else {
+            cause = {
+                name: 'Error',
+                message: 'Fetch failed',
+                data: {},
+            };
         }
-        cause || (cause = {
-            name: 'Error',
-            message: 'Fetch failed',
-            data: {},
-        });
         let responseStatusCode = res.fetchResponse?.status || 0;
         if (res.statusFamily === 2) {
             // important to reset responseStatusCode to 0 in this case, as status 2xx can be misleading

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.252.0",
+  "version": "14.252.1",
   "scripts": {
     "prepare": "husky",
     "build": "dev-lib build-esm-cjs",

package/src/error/assert.ts

@@ -1,5 +1,14 @@
-import type { ErrorData, ErrorObject } from '..'
-import { _deepEquals, _isErrorObject, _stringify, AssertionError, Class } from '..'
+import {
+  _deepEquals,
+  _isBackendErrorResponseObject,
+  _isErrorObject,
+  _stringify,
+  AssertionError,
+  BackendErrorResponseObject,
+  Class,
+  ErrorData,
+  ErrorObject,
+} from '..'
 
 /**
  * Evaluates the `condition` (casts it to Boolean).
@@ -113,6 +122,16 @@ export function _assertIsErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   }
 }
 
+export function _assertIsBackendErrorResponseObject<DATA_TYPE extends ErrorData = ErrorData>(
+  obj: any,
+): asserts obj is BackendErrorResponseObject<DATA_TYPE> {
+  if (!_isBackendErrorResponseObject(obj)) {
+    throw new AssertionError(
+      `Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`,
+    )
+  }
+}
+
 export function _assertIsString(v: any, message?: string): asserts v is string {
   _assertTypeOf<string>(v, 'string', message)
 }

package/src/http/fetcher.ts

@@ -416,24 +416,31 @@ export class Fetcher {
   private async onNotOkResponse(res: FetcherResponse): Promise<void> {
     let cause: ErrorObject
 
+    // Try to fetch body and attach to res.body
+    // (but don't fail if it doesn't work)
+    if (!res.body && res.fetchResponse) {
+      try {
+        res.body = _jsonParseIfPossible(await res.fetchResponse.text())
+      } catch {
+        // ignore body fetching/parsing errors at this point
+      }
+    }
+
     if (res.err) {
       // This is only possible on JSON.parse error, or CORS error,
       // or `unexpected redirect`
       // This check should go first, to avoid calling .text() twice (which will fail)
       cause = _errorLikeToErrorObject(res.err)
-    } else if (res.fetchResponse) {
-      const body = _jsonParseIfPossible(await res.fetchResponse.text())
-      if (body) {
-        cause = _anyToErrorObject(body)
+    } else if (res.body) {
+      cause = _anyToErrorObject(res.body)
+    } else {
+      cause = {
+        name: 'Error',
+        message: 'Fetch failed',
+        data: {},
       }
     }
 
-    cause ||= {
-      name: 'Error',
-      message: 'Fetch failed',
-      data: {},
-    }
-
     let responseStatusCode = res.fetchResponse?.status || 0
     if (res.statusFamily === 2) {
       // important to reset responseStatusCode to 0 in this case, as status 2xx can be misleading