@naturalcycles/js-lib 14.174.1 → 14.175.0

package/dist/error/assert.js

@@ -20,7 +20,7 @@ const __1 = require("..");
 function _assert(condition, // will be evaluated as Boolean
 message, errorData) {
     if (!condition) {
-        throw new __1.AssertionError(message || 'see stacktrace', {
+        throw new __1.AssertionError(message || 'condition failed', {
             userFriendly: true,
             ...errorData,
         });
@@ -71,11 +71,7 @@ function _assertDeepEquals(actual, expected, message, errorData) {
 exports._assertDeepEquals = _assertDeepEquals;
 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 __1.AssertionError(msg, {
+        throw new __1.AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`, {
             userFriendly: true,
         });
     }
@@ -95,8 +91,7 @@ function _assertErrorClassOrRethrow(err, errorClass) {
 exports._assertErrorClassOrRethrow = _assertErrorClassOrRethrow;
 function _assertIsErrorObject(obj) {
     if (!(0, __1._isErrorObject)(obj)) {
-        const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n');
-        throw new __1.AssertionError(msg, {
+        throw new __1.AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`, {
             userFriendly: true,
         });
     }
@@ -112,11 +107,7 @@ function _assertIsNumber(v, message) {
 exports._assertIsNumber = _assertIsNumber;
 function _assertTypeOf(v, expectedType, message) {
     if (typeof v !== expectedType) {
-        const msg = [
-            message || `unexpected type`,
-            `expected: ${expectedType}`,
-            `got     : ${typeof v}`,
-        ].join('\n');
+        const msg = message || `Expected typeof ${expectedType}, actual typeof: ${typeof v}`;
         throw new __1.AssertionError(msg, {
             userFriendly: true,
         });

package/dist/error/error.util.d.ts

@@ -143,5 +143,5 @@ export declare class TimeoutError extends AppError {
  * "Pass" means "no error".
  */
 export declare class UnexpectedPassError extends AppError {
-    constructor();
+    constructor(message?: string);
 }

package/dist/error/error.util.js

@@ -342,8 +342,8 @@ exports.TimeoutError = TimeoutError;
  * "Pass" means "no error".
  */
 class UnexpectedPassError extends AppError {
-    constructor() {
-        super('expected error was not thrown', {}, {
+    constructor(message) {
+        super(message || 'expected error was not thrown', {}, {
             name: 'UnexpectedPassError',
         });
     }

package/dist/error/try.js

@@ -61,18 +61,16 @@ exports.pTry = pTry;
 function _expectedError(fn, errorClass) {
     try {
         fn();
-        // Unexpected!
-        throw new error_util_1.UnexpectedPassError();
     }
     catch (err) {
-        if (err instanceof error_util_1.UnexpectedPassError)
-            throw err; // re-throw
         if (errorClass && !(err instanceof errorClass)) {
             console.warn(`_expectedError expected ${errorClass.constructor.name} but got different error class`);
             throw err;
         }
         return err; // this is expected!
     }
+    // Unexpected!
+    throw new error_util_1.UnexpectedPassError();
 }
 exports._expectedError = _expectedError;
 /**
@@ -86,18 +84,16 @@ exports._expectedError = _expectedError;
 async function pExpectedError(promise, errorClass) {
     try {
         await promise;
-        // Unexpected!
-        throw new error_util_1.UnexpectedPassError();
     }
     catch (err) {
-        if (err instanceof error_util_1.UnexpectedPassError)
-            throw err; // re-throw
         if (errorClass && !(err instanceof errorClass)) {
             console.warn(`pExpectedError expected ${errorClass.constructor.name} but got different error class`);
             throw err;
         }
         return err; // this is expected!
     }
+    // Unexpected!
+    throw new error_util_1.UnexpectedPassError();
 }
 exports.pExpectedError = pExpectedError;
 /**

package/dist/http/fetcher.d.ts

@@ -50,6 +50,13 @@ export declare class Fetcher {
      */
     getReadableStream(url: string, opt?: FetcherOptions): Promise<ReadableStream<Uint8Array>>;
     fetch<T = unknown>(opt: FetcherOptions): Promise<T>;
+    /**
+     * Execute fetch and expect/assert it to return an Error (which will be wrapped in
+     * HttpRequestError as it normally would).
+     * If fetch succeeds, which is unexpected, it'll throw an UnexpectedPass error.
+     * Useful in unit testing.
+     */
+    expectError(opt: FetcherOptions): Promise<HttpRequestError>;
     /**
      * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
      * err, if defined, is strictly HttpRequestError.

package/dist/http/fetcher.js

@@ -121,6 +121,20 @@ class Fetcher {
         }
         return res.body;
     }
+    /**
+     * Execute fetch and expect/assert it to return an Error (which will be wrapped in
+     * HttpRequestError as it normally would).
+     * If fetch succeeds, which is unexpected, it'll throw an UnexpectedPass error.
+     * Useful in unit testing.
+     */
+    async expectError(opt) {
+        const res = await this.doFetch(opt);
+        if (!res.err) {
+            throw new error_util_1.UnexpectedPassError('Fetch was expected to error');
+        }
+        (0, assert_1._assertIsError)(res.err, error_util_1.HttpRequestError);
+        return res.err;
+    }
     /**
      * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
      * err, if defined, is strictly HttpRequestError.
@@ -168,6 +182,9 @@ class Fetcher {
             // setup timeout
             let timeoutId;
             if (timeoutSeconds) {
+                // Used for Request timeout (when timeoutSeconds is set),
+                // but also for "downloadBody" timeout (even after request returned with 200, but before we loaded the body)
+                // UPD: no, not using for "downloadBody" currently
                 const abortController = new AbortController();
                 req.init.signal = abortController.signal;
                 timeoutId = setTimeout(() => {
@@ -211,10 +228,13 @@ class Fetcher {
                     // We are applying a separate Timeout (as long as original Timeout for now) to "download and parse the body"
                     await (0, pTimeout_1.pTimeout)(async () => await this.onOkResponse(res), {
                         timeout: timeoutSeconds * 1000 || Number.POSITIVE_INFINITY,
-                        name: 'Fetcher.onOkResponse',
+                        name: 'Fetcher.downloadBody',
                     });
                 }
                 catch (err) {
+                    // Important to cancel the original request to not keep it running (and occupying resources)
+                    // UPD: no, we probably don't need to, because "request" has already completed, it's just the "body" is pending
+                    // if (err instanceof TimeoutError) {}
                     // onOkResponse can still fail, e.g when loading/parsing json, text or doing other response manipulation
                     res.err = (0, error_util_1._anyToError)(err);
                     res.ok = false;
@@ -315,10 +335,17 @@ class Fetcher {
             message: 'Fetch failed',
             data: {},
         };
-        const message = [res.fetchResponse?.status, res.signature].filter(Boolean).join(' ');
+        let responseStatusCode = res.fetchResponse?.status || 0;
+        if (res.statusFamily === 2) {
+            // important to reset httpStatusCode to 0 in this case, as status 2xx can be misleading
+            res.statusFamily = undefined;
+            res.statusCode = undefined;
+            responseStatusCode = 0;
+        }
+        const message = [res.statusCode, res.signature].filter(Boolean).join(' ');
         res.err = new error_util_1.HttpRequestError(message, (0, object_util_1._filterNullishValues)({
             response: res.fetchResponse,
-            responseStatusCode: res.fetchResponse?.status || 0,
+            responseStatusCode,
             // 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

package/dist-esm/error/assert.js

@@ -17,7 +17,7 @@ import { _deepEquals, _isErrorObject, _stringifyAny, AssertionError } from '..';
 export function _assert(condition, // will be evaluated as Boolean
 message, errorData) {
     if (!condition) {
-        throw new AssertionError(message || 'see stacktrace', Object.assign({ userFriendly: true }, errorData));
+        throw new AssertionError(message || 'condition failed', Object.assign({ userFriendly: true }, errorData));
     }
 }
 /**
@@ -56,11 +56,7 @@ export function _assertDeepEquals(actual, expected, message, errorData) {
 }
 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, {
+        throw new AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`, {
             userFriendly: true,
         });
     }
@@ -78,8 +74,7 @@ export function _assertErrorClassOrRethrow(err, errorClass) {
 }
 export function _assertIsErrorObject(obj) {
     if (!_isErrorObject(obj)) {
-        const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n');
-        throw new AssertionError(msg, {
+        throw new AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`, {
             userFriendly: true,
         });
     }
@@ -92,11 +87,7 @@ export function _assertIsNumber(v, message) {
 }
 export function _assertTypeOf(v, expectedType, message) {
     if (typeof v !== expectedType) {
-        const msg = [
-            message || `unexpected type`,
-            `expected: ${expectedType}`,
-            `got     : ${typeof v}`,
-        ].join('\n');
+        const msg = message || `Expected typeof ${expectedType}, actual typeof: ${typeof v}`;
         throw new AssertionError(msg, {
             userFriendly: true,
         });

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

@@ -319,8 +319,8 @@ export class TimeoutError extends AppError {
  * "Pass" means "no error".
  */
 export class UnexpectedPassError extends AppError {
-    constructor() {
-        super('expected error was not thrown', {}, {
+    constructor(message) {
+        super(message || 'expected error was not thrown', {}, {
             name: 'UnexpectedPassError',
         });
     }

package/dist-esm/error/try.js

@@ -56,18 +56,16 @@ export async function pTry(promise, errorClass) {
 export function _expectedError(fn, errorClass) {
     try {
         fn();
-        // Unexpected!
-        throw new UnexpectedPassError();
     }
     catch (err) {
-        if (err instanceof UnexpectedPassError)
-            throw err; // re-throw
         if (errorClass && !(err instanceof errorClass)) {
             console.warn(`_expectedError expected ${errorClass.constructor.name} but got different error class`);
             throw err;
         }
         return err; // this is expected!
     }
+    // Unexpected!
+    throw new UnexpectedPassError();
 }
 /**
  * Awaits passed `promise`, expects is to throw (reject), catches the expected error and returns.
@@ -80,18 +78,16 @@ export function _expectedError(fn, errorClass) {
 export async function pExpectedError(promise, errorClass) {
     try {
         await promise;
-        // Unexpected!
-        throw new UnexpectedPassError();
     }
     catch (err) {
-        if (err instanceof UnexpectedPassError)
-            throw err; // re-throw
         if (errorClass && !(err instanceof errorClass)) {
             console.warn(`pExpectedError expected ${errorClass.constructor.name} but got different error class`);
             throw err;
         }
         return err; // this is expected!
     }
+    // Unexpected!
+    throw new UnexpectedPassError();
 }
 /**
  * Shortcut function to simplify error snapshot-matching in tests.

package/dist-esm/http/fetcher.js

@@ -3,8 +3,8 @@
 /// <reference lib="dom.iterable"/>
 var _a;
 import { isServerSide } from '../env';
-import { _assertErrorClassOrRethrow } from '../error/assert';
-import { _anyToError, _anyToErrorObject, _errorLikeToErrorObject, HttpRequestError, TimeoutError, } from '../error/error.util';
+import { _assertErrorClassOrRethrow, _assertIsError } from '../error/assert';
+import { _anyToError, _anyToErrorObject, _errorLikeToErrorObject, HttpRequestError, TimeoutError, UnexpectedPassError, } from '../error/error.util';
 import { _clamp } from '../number/number.util';
 import { _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, _pick, } from '../object/object.util';
 import { pDelay } from '../promise/pDelay';
@@ -98,6 +98,20 @@ export class Fetcher {
         }
         return res.body;
     }
+    /**
+     * Execute fetch and expect/assert it to return an Error (which will be wrapped in
+     * HttpRequestError as it normally would).
+     * If fetch succeeds, which is unexpected, it'll throw an UnexpectedPass error.
+     * Useful in unit testing.
+     */
+    async expectError(opt) {
+        const res = await this.doFetch(opt);
+        if (!res.err) {
+            throw new UnexpectedPassError('Fetch was expected to error');
+        }
+        _assertIsError(res.err, HttpRequestError);
+        return res.err;
+    }
     /**
      * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
      * err, if defined, is strictly HttpRequestError.
@@ -146,6 +160,9 @@ export class Fetcher {
             // setup timeout
             let timeoutId;
             if (timeoutSeconds) {
+                // Used for Request timeout (when timeoutSeconds is set),
+                // but also for "downloadBody" timeout (even after request returned with 200, but before we loaded the body)
+                // UPD: no, not using for "downloadBody" currently
                 const abortController = new AbortController();
                 req.init.signal = abortController.signal;
                 timeoutId = setTimeout(() => {
@@ -189,10 +206,13 @@ export class Fetcher {
                     // We are applying a separate Timeout (as long as original Timeout for now) to "download and parse the body"
                     await pTimeout(async () => await this.onOkResponse(res), {
                         timeout: timeoutSeconds * 1000 || Number.POSITIVE_INFINITY,
-                        name: 'Fetcher.onOkResponse',
+                        name: 'Fetcher.downloadBody',
                     });
                 }
                 catch (err) {
+                    // Important to cancel the original request to not keep it running (and occupying resources)
+                    // UPD: no, we probably don't need to, because "request" has already completed, it's just the "body" is pending
+                    // if (err instanceof TimeoutError) {}
                     // onOkResponse can still fail, e.g when loading/parsing json, text or doing other response manipulation
                     res.err = _anyToError(err);
                     res.ok = false;
@@ -275,7 +295,7 @@ export class Fetcher {
         return await globalThis.fetch(url, init);
     }
     async onNotOkResponse(res) {
-        var _b, _c;
+        var _b;
         let cause;
         if (res.err) {
             // This is only possible on JSON.parse error, or CORS error,
@@ -294,10 +314,17 @@ export class Fetcher {
             message: 'Fetch failed',
             data: {},
         });
-        const message = [(_b = res.fetchResponse) === null || _b === void 0 ? void 0 : _b.status, res.signature].filter(Boolean).join(' ');
+        let responseStatusCode = ((_b = res.fetchResponse) === null || _b === void 0 ? void 0 : _b.status) || 0;
+        if (res.statusFamily === 2) {
+            // important to reset httpStatusCode to 0 in this case, as status 2xx can be misleading
+            res.statusFamily = undefined;
+            res.statusCode = undefined;
+            responseStatusCode = 0;
+        }
+        const message = [res.statusCode, res.signature].filter(Boolean).join(' ');
         res.err = new HttpRequestError(message, _filterNullishValues({
             response: res.fetchResponse,
-            responseStatusCode: ((_c = res.fetchResponse) === null || _c === void 0 ? void 0 : _c.status) || 0,
+            responseStatusCode,
             // 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

package/package.json

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

package/src/error/assert.ts

@@ -22,7 +22,7 @@ export function _assert(
   errorData?: ErrorData,
 ): asserts condition {
   if (!condition) {
-    throw new AssertionError(message || 'see stacktrace', {
+    throw new AssertionError(message || 'condition failed', {
       userFriendly: true,
       ...errorData,
     })
@@ -90,14 +90,12 @@ export function _assertIsError<ERR extends Error = Error>(
   errorClass: Class<ERR> = Error as any,
 ): asserts err is ERR {
   if (!(err instanceof errorClass)) {
-    const msg = [
-      `expected to be instanceof ${errorClass.name}`,
-      `actual typeof: ${typeof err}`,
-    ].join('\n')
-
-    throw new AssertionError(msg, {
-      userFriendly: true,
-    })
+    throw new AssertionError(
+      `Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`,
+      {
+        userFriendly: true,
+      },
+    )
   }
 }
 
@@ -120,9 +118,7 @@ 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, {
+    throw new AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`, {
       userFriendly: true,
     })
   }
@@ -138,12 +134,7 @@ export function _assertIsNumber(v: any, message?: string): asserts v is number {
 
 export function _assertTypeOf<T>(v: any, expectedType: string, message?: string): asserts v is T {
   if (typeof v !== expectedType) {
-    const msg = [
-      message || `unexpected type`,
-      `expected: ${expectedType}`,
-      `got     : ${typeof v}`,
-    ].join('\n')
-
+    const msg = message || `Expected typeof ${expectedType}, actual typeof: ${typeof v}`
     throw new AssertionError(msg, {
       userFriendly: true,
     })

package/src/error/error.util.ts

@@ -441,9 +441,9 @@ export class TimeoutError extends AppError {
  * "Pass" means "no error".
  */
 export class UnexpectedPassError extends AppError {
-  constructor() {
+  constructor(message?: string) {
     super(
-      'expected error was not thrown',
+      message || 'expected error was not thrown',
       {},
       {
         name: 'UnexpectedPassError',

package/src/error/try.ts

@@ -66,10 +66,7 @@ export async function pTry<T, ERR extends Error = Error>(
 export function _expectedError<ERR = Error>(fn: AnyFunction, errorClass?: Class<ERR>): ERR {
   try {
     fn()
-    // Unexpected!
-    throw new UnexpectedPassError()
   } catch (err) {
-    if (err instanceof UnexpectedPassError) throw err // re-throw
     if (errorClass && !(err instanceof errorClass)) {
       console.warn(
         `_expectedError expected ${errorClass.constructor.name} but got different error class`,
@@ -78,6 +75,9 @@ export function _expectedError<ERR = Error>(fn: AnyFunction, errorClass?: Class<
     }
     return err as ERR // this is expected!
   }
+
+  // Unexpected!
+  throw new UnexpectedPassError()
 }
 
 /**
@@ -94,10 +94,7 @@ export async function pExpectedError<ERR = Error>(
 ): Promise<ERR> {
   try {
     await promise
-    // Unexpected!
-    throw new UnexpectedPassError()
   } catch (err) {
-    if (err instanceof UnexpectedPassError) throw err // re-throw
     if (errorClass && !(err instanceof errorClass)) {
       console.warn(
         `pExpectedError expected ${errorClass.constructor.name} but got different error class`,
@@ -106,6 +103,9 @@ export async function pExpectedError<ERR = Error>(
     }
     return err as ERR // this is expected!
   }
+
+  // Unexpected!
+  throw new UnexpectedPassError()
 }
 
 /**

package/src/http/fetcher.ts

@@ -3,7 +3,7 @@
 /// <reference lib="dom.iterable"/>
 
 import { isServerSide } from '../env'
-import { _assertErrorClassOrRethrow } from '../error/assert'
+import { _assertErrorClassOrRethrow, _assertIsError } from '../error/assert'
 import { ErrorLike, ErrorObject } from '../error/error.model'
 import {
   _anyToError,
@@ -11,6 +11,7 @@ import {
   _errorLikeToErrorObject,
   HttpRequestError,
   TimeoutError,
+  UnexpectedPassError,
 } from '../error/error.util'
 import { _clamp } from '../number/number.util'
 import {
@@ -186,6 +187,23 @@ export class Fetcher {
     return res.body
   }
 
+  /**
+   * Execute fetch and expect/assert it to return an Error (which will be wrapped in
+   * HttpRequestError as it normally would).
+   * If fetch succeeds, which is unexpected, it'll throw an UnexpectedPass error.
+   * Useful in unit testing.
+   */
+  async expectError(opt: FetcherOptions): Promise<HttpRequestError> {
+    const res = await this.doFetch(opt)
+
+    if (!res.err) {
+      throw new UnexpectedPassError('Fetch was expected to error')
+    }
+
+    _assertIsError(res.err, HttpRequestError)
+    return res.err
+  }
+
   /**
    * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
    * err, if defined, is strictly HttpRequestError.
@@ -242,6 +260,9 @@ export class Fetcher {
       // setup timeout
       let timeoutId: number | undefined
       if (timeoutSeconds) {
+        // Used for Request timeout (when timeoutSeconds is set),
+        // but also for "downloadBody" timeout (even after request returned with 200, but before we loaded the body)
+        // UPD: no, not using for "downloadBody" currently
         const abortController = new AbortController()
         req.init.signal = abortController.signal
         timeoutId = setTimeout(() => {
@@ -291,10 +312,14 @@ export class Fetcher {
               await this.onOkResponse(res as FetcherResponse<T> & { fetchResponse: Response }),
             {
               timeout: timeoutSeconds * 1000 || Number.POSITIVE_INFINITY,
-              name: 'Fetcher.onOkResponse',
+              name: 'Fetcher.downloadBody',
             },
           )
         } catch (err) {
+          // Important to cancel the original request to not keep it running (and occupying resources)
+          // UPD: no, we probably don't need to, because "request" has already completed, it's just the "body" is pending
+          // if (err instanceof TimeoutError) {}
+
           // onOkResponse can still fail, e.g when loading/parsing json, text or doing other response manipulation
           res.err = _anyToError(err)
           res.ok = false
@@ -405,13 +430,21 @@ export class Fetcher {
       data: {},
     }
 
-    const message = [res.fetchResponse?.status, res.signature].filter(Boolean).join(' ')
+    let responseStatusCode = res.fetchResponse?.status || 0
+    if (res.statusFamily === 2) {
+      // important to reset httpStatusCode to 0 in this case, as status 2xx can be misleading
+      res.statusFamily = undefined
+      res.statusCode = undefined
+      responseStatusCode = 0
+    }
+
+    const message = [res.statusCode, res.signature].filter(Boolean).join(' ')
 
     res.err = new HttpRequestError(
       message,
       _filterNullishValues({
         response: res.fetchResponse,
-        responseStatusCode: res.fetchResponse?.status || 0,
+        responseStatusCode,
         // 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