@naturalcycles/js-lib 14.157.1 → 14.159.0

package/dist/error/assert.d.ts

@@ -33,6 +33,12 @@ export declare function _assertEquals<T>(actual: any, expected: T, message?: str
  */
 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, errorClass?: Class<ERR>): asserts err is ERR;
+/**
+ * Asserts that passed object is indeed an Error of defined ErrorClass.
+ * If yes - returns peacefully (with TypeScript assertion).
+ * In not - throws (re-throws) that error up.
+ */
+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 _assertIsString(v: any, message?: string): asserts v is string;
 export declare function _assertIsNumber(v: any, message?: string): asserts v is number;

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._assertIsErrorObject = exports._assertIsError = exports._assertDeepEquals = exports._assertEquals = exports._assert = void 0;
+exports.AssertionError = exports._assertTypeOf = exports._assertIsNumber = exports._assertIsString = exports._assertIsErrorObject = exports._assertErrorClassOrRethrow = exports._assertIsError = exports._assertDeepEquals = exports._assertEquals = exports._assert = void 0;
 const __1 = require("..");
 const app_error_1 = require("./app.error");
 /**
@@ -84,6 +84,18 @@ function _assertIsError(err, errorClass = Error) {
     }
 }
 exports._assertIsError = _assertIsError;
+/**
+ * Asserts that passed object is indeed an Error of defined ErrorClass.
+ * If yes - returns peacefully (with TypeScript assertion).
+ * In not - throws (re-throws) that error up.
+ */
+function _assertErrorClassOrRethrow(err, errorClass) {
+    if (!(err instanceof errorClass)) {
+        // re-throw
+        throw err;
+    }
+}
+exports._assertErrorClassOrRethrow = _assertErrorClassOrRethrow;
 function _assertIsErrorObject(obj) {
     if (!(0, __1._isErrorObject)(obj)) {
         const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n');

package/dist/error/httpRequestError.d.ts

@@ -18,5 +18,11 @@ import type { ErrorObject, HttpRequestErrorData } from './error.model';
  * (by default).
  */
 export declare class HttpRequestError extends AppError<HttpRequestErrorData> {
-    constructor(message: string, data: HttpRequestErrorData, cause?: ErrorObject);
+    constructor(message: string, data: HttpRequestErrorData, cause: ErrorObject);
+    /**
+     * Cause is strictly-defined for HttpRequestError,
+     * so it always has a cause.
+     * (for dev convenience)
+     */
+    cause: ErrorObject;
 }

package/dist/error/try.d.ts

@@ -1,5 +1,5 @@
 import type { Class } from '../typeFest';
-import type { AnyFunction } from '../types';
+import type { AnyFunction, ErrorDataTuple } from '../types';
 import { AppError } from './app.error';
 /**
  * Calls a function, returns a Tuple of [error, value].
@@ -8,9 +8,6 @@ import { AppError } from './app.error';
  *
  * Similar to pTry, but for sync functions.
  *
- * For convenience, second argument type is non-optional,
- * so you can use it without `!`. But you SHOULD always check `if (err)` first!
- *
  * ERR is typed as Error, not `unknown`. While unknown would be more correct,
  * according to recent TypeScript, Error gives more developer convenience.
  * In our code we NEVER throw non-errors.
@@ -23,14 +20,11 @@ import { AppError } from './app.error';
  * if (err) ...do something...
  * v // go ahead and use v
  */
-export declare function _try<ERR = Error, RETURN = void>(fn: () => RETURN): [err: ERR | null, value: RETURN];
+export declare function _try<T, ERR extends Error = Error>(fn: () => T, errorClass?: Class<ERR>): ErrorDataTuple<T, ERR>;
 /**
  * Like _try, but for Promises.
- *
- * Also, intentionally types second return item as non-optional,
- * but you should check for `err` presense first!
  */
-export declare function pTry<ERR = Error, RETURN = void>(promise: Promise<RETURN>): Promise<[err: ERR | null, value: Awaited<RETURN>]>;
+export declare function pTry<T, ERR extends Error = Error>(promise: Promise<T>, errorClass?: Class<ERR>): Promise<ErrorDataTuple<Awaited<T>, ERR>>;
 /**
  * It is thrown when Error was expected, but didn't happen
  * ("pass" happened instead).
@@ -61,3 +55,7 @@ export declare function pExpectedError<ERR = Error>(promise: Promise<any>, error
  * Shortcut function to simplify error snapshot-matching in tests.
  */
 export declare function pExpectedErrorString<ERR = Error>(promise: Promise<any>, errorClass?: Class<ERR>): Promise<string>;
+/**
+ * Shortcut function to simplify error snapshot-matching in tests.
+ */
+export declare function _expectedErrorString<ERR = Error>(fn: AnyFunction, errorClass?: Class<ERR>): string;

package/dist/error/try.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pExpectedErrorString = exports.pExpectedError = exports._expectedError = exports.UnexpectedPassError = exports.pTry = exports._try = void 0;
+exports._expectedErrorString = exports.pExpectedErrorString = exports.pExpectedError = exports._expectedError = exports.UnexpectedPassError = exports.pTry = exports._try = void 0;
 const stringifyAny_1 = require("../string/stringifyAny");
 const app_error_1 = require("./app.error");
+const assert_1 = require("./assert");
 /**
  * Calls a function, returns a Tuple of [error, value].
  * Allows to write shorter code that avoids `try/catch`.
@@ -10,9 +11,6 @@ const app_error_1 = require("./app.error");
  *
  * Similar to pTry, but for sync functions.
  *
- * For convenience, second argument type is non-optional,
- * so you can use it without `!`. But you SHOULD always check `if (err)` first!
- *
  * ERR is typed as Error, not `unknown`. While unknown would be more correct,
  * according to recent TypeScript, Error gives more developer convenience.
  * In our code we NEVER throw non-errors.
@@ -25,27 +23,30 @@ const app_error_1 = require("./app.error");
  * if (err) ...do something...
  * v // go ahead and use v
  */
-function _try(fn) {
+function _try(fn, errorClass) {
     try {
         return [null, fn()];
     }
     catch (err) {
-        return [err, undefined];
+        if (errorClass) {
+            (0, assert_1._assertErrorClassOrRethrow)(err, errorClass);
+        }
+        return [err, null];
     }
 }
 exports._try = _try;
 /**
  * Like _try, but for Promises.
- *
- * Also, intentionally types second return item as non-optional,
- * but you should check for `err` presense first!
  */
-async function pTry(promise) {
+async function pTry(promise, errorClass) {
     try {
         return [null, await promise];
     }
     catch (err) {
-        return [err, undefined];
+        if (errorClass) {
+            (0, assert_1._assertErrorClassOrRethrow)(err, errorClass);
+        }
+        return [err, null];
     }
 }
 exports.pTry = pTry;
@@ -114,6 +115,15 @@ exports.pExpectedError = pExpectedError;
  * Shortcut function to simplify error snapshot-matching in tests.
  */
 async function pExpectedErrorString(promise, errorClass) {
-    return (0, stringifyAny_1._stringifyAny)(await pExpectedError(promise, errorClass));
+    const err = await pExpectedError(promise, errorClass);
+    return (0, stringifyAny_1._stringifyAny)(err);
 }
 exports.pExpectedErrorString = pExpectedErrorString;
+/**
+ * Shortcut function to simplify error snapshot-matching in tests.
+ */
+function _expectedErrorString(fn, errorClass) {
+    const err = _expectedError(fn, errorClass);
+    return (0, stringifyAny_1._stringifyAny)(err);
+}
+exports._expectedErrorString = _expectedErrorString;

package/dist/http/fetcher.d.ts

@@ -1,6 +1,8 @@
 /// <reference lib="dom" />
 /// <reference lib="dom.iterable" />
-import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherNormalizedCfg, FetcherOptions, FetcherResponse } from './fetcher.model';
+import { HttpRequestError } from '../error/httpRequestError';
+import { ErrorDataTuple } from '../types';
+import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherNormalizedCfg, FetcherOptions, FetcherResponse, RequestInitNormalized } from './fetcher.model';
 /**
  * Experimental wrapper around Fetch.
  * Works in both Browser and Node, using `globalThis.fetch`.
@@ -39,17 +41,28 @@ export declare class Fetcher {
      */
     getReadableStream(url: string, opt?: FetcherOptions): Promise<ReadableStream<Uint8Array>>;
     fetch<T = unknown>(opt: FetcherOptions): Promise<T>;
+    /**
+     * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
+     * err, if defined, is strictly HttpRequestError.
+     * UPD: actually not, err is typed as Error, as it feels unsafe to guarantee error type.
+     * UPD: actually yes - it will return HttpRequestError, and throw if there's an error
+     * of any other type.
+     */
+    tryFetch<T = unknown>(opt: FetcherOptions): Promise<ErrorDataTuple<T, HttpRequestError>>;
     /**
      * Returns FetcherResponse.
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
+     *
+     * Note: responseType defaults to `void`, so, override it if you expect different.
      */
     doFetch<T = unknown>(opt: FetcherOptions): Promise<FetcherResponse<T>>;
     private onOkResponse;
     /**
      * This method exists to be able to easily mock it.
+     * It is static, so mocking applies to ALL instances (even future ones) of Fetcher at once.
      */
-    callNativeFetch(url: string, init: RequestInit): Promise<Response>;
+    static callNativeFetch(url: string, init: RequestInitNormalized): Promise<Response>;
     private onNotOkResponse;
     private processRetry;
     private getRetryTimeout;

package/dist/http/fetcher.js

@@ -4,6 +4,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFetcher = exports.Fetcher = void 0;
 const env_1 = require("../env");
+const assert_1 = require("../error/assert");
 const error_util_1 = require("../error/error.util");
 const httpRequestError_1 = require("../error/httpRequestError");
 const number_util_1 = require("../number/number.util");
@@ -112,10 +113,27 @@ class Fetcher {
         }
         return res.body;
     }
+    /**
+     * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
+     * err, if defined, is strictly HttpRequestError.
+     * UPD: actually not, err is typed as Error, as it feels unsafe to guarantee error type.
+     * UPD: actually yes - it will return HttpRequestError, and throw if there's an error
+     * of any other type.
+     */
+    async tryFetch(opt) {
+        const res = await this.doFetch(opt);
+        if (res.err) {
+            (0, assert_1._assertErrorClassOrRethrow)(res.err, httpRequestError_1.HttpRequestError);
+            return [res.err, null];
+        }
+        return [null, res.body];
+    }
     /**
      * Returns FetcherResponse.
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
+     *
+     * Note: responseType defaults to `void`, so, override it if you expect different.
      */
     async doFetch(opt) {
         const req = this.normalizeOptions(opt);
@@ -161,7 +179,7 @@ class Fetcher {
                 }
             }
             try {
-                res.fetchResponse = await this.callNativeFetch(req.fullUrl, req.init);
+                res.fetchResponse = await Fetcher.callNativeFetch(req.fullUrl, req.init);
                 res.ok = res.fetchResponse.ok;
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.err = undefined;
@@ -265,8 +283,9 @@ class Fetcher {
     }
     /**
      * This method exists to be able to easily mock it.
+     * It is static, so mocking applies to ALL instances (even future ones) of Fetcher at once.
      */
-    async callNativeFetch(url, init) {
+    static async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
     async onNotOkResponse(res) {
@@ -283,6 +302,11 @@ class Fetcher {
                 cause = (0, error_util_1._anyToErrorObject)(body);
             }
         }
+        cause ||= {
+            name: 'Error',
+            message: 'Fetch failed',
+            data: {},
+        };
         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,
@@ -441,7 +465,7 @@ class Fetcher {
         const norm = (0, object_util_1._merge)({
             baseUrl: '',
             inputUrl: '',
-            responseType: 'void',
+            responseType: 'json',
             searchParams: {},
             timeoutSeconds: 30,
             retryPost: false,

package/dist/types.d.ts

@@ -207,3 +207,14 @@ export declare function _typeCast<T>(v: any): asserts v is T;
  * Type-safe Object.assign that checks that part is indeed a Partial<T>
  */
 export declare const _objectAssign: <T extends AnyObject>(target: T, part: Partial<T>) => T;
+/**
+ * Defines a tuple of [err, data]
+ * where only 1 of them exists.
+ * Either error exists and data is null
+ * Or error is null and data is defined.
+ * This forces you to check `if (err)`, which lets
+ * TypeScript infer the existence of `data`.
+ *
+ * Functions like pTry use that.
+ */
+export type ErrorDataTuple<T = unknown, ERR = Error> = [err: null, data: T] | [err: ERR, data: null];

package/dist-esm/error/assert.js

@@ -68,6 +68,17 @@ export function _assertIsError(err, errorClass = Error) {
         });
     }
 }
+/**
+ * Asserts that passed object is indeed an Error of defined ErrorClass.
+ * If yes - returns peacefully (with TypeScript assertion).
+ * In not - throws (re-throws) that error up.
+ */
+export function _assertErrorClassOrRethrow(err, errorClass) {
+    if (!(err instanceof errorClass)) {
+        // re-throw
+        throw err;
+    }
+}
 export function _assertIsErrorObject(obj) {
     if (!_isErrorObject(obj)) {
         const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n');

package/dist-esm/error/try.js

@@ -1,5 +1,6 @@
 import { _stringifyAny } from '../string/stringifyAny';
 import { AppError } from './app.error';
+import { _assertErrorClassOrRethrow } from './assert';
 /**
  * Calls a function, returns a Tuple of [error, value].
  * Allows to write shorter code that avoids `try/catch`.
@@ -7,9 +8,6 @@ import { AppError } from './app.error';
  *
  * Similar to pTry, but for sync functions.
  *
- * For convenience, second argument type is non-optional,
- * so you can use it without `!`. But you SHOULD always check `if (err)` first!
- *
  * ERR is typed as Error, not `unknown`. While unknown would be more correct,
  * according to recent TypeScript, Error gives more developer convenience.
  * In our code we NEVER throw non-errors.
@@ -22,26 +20,29 @@ import { AppError } from './app.error';
  * if (err) ...do something...
  * v // go ahead and use v
  */
-export function _try(fn) {
+export function _try(fn, errorClass) {
     try {
         return [null, fn()];
     }
     catch (err) {
-        return [err, undefined];
+        if (errorClass) {
+            _assertErrorClassOrRethrow(err, errorClass);
+        }
+        return [err, null];
     }
 }
 /**
  * Like _try, but for Promises.
- *
- * Also, intentionally types second return item as non-optional,
- * but you should check for `err` presense first!
  */
-export async function pTry(promise) {
+export async function pTry(promise, errorClass) {
     try {
         return [null, await promise];
     }
     catch (err) {
-        return [err, undefined];
+        if (errorClass) {
+            _assertErrorClassOrRethrow(err, errorClass);
+        }
+        return [err, null];
     }
 }
 /**
@@ -106,5 +107,13 @@ export async function pExpectedError(promise, errorClass) {
  * Shortcut function to simplify error snapshot-matching in tests.
  */
 export async function pExpectedErrorString(promise, errorClass) {
-    return _stringifyAny(await pExpectedError(promise, errorClass));
+    const err = await pExpectedError(promise, errorClass);
+    return _stringifyAny(err);
+}
+/**
+ * Shortcut function to simplify error snapshot-matching in tests.
+ */
+export function _expectedErrorString(fn, errorClass) {
+    const err = _expectedError(fn, errorClass);
+    return _stringifyAny(err);
 }

package/dist-esm/http/fetcher.js

@@ -1,6 +1,7 @@
 /// <reference lib="dom"/>
 /// <reference lib="dom.iterable"/>
 import { isServerSide } from '../env';
+import { _assertErrorClassOrRethrow } from '../error/assert';
 import { _anyToError, _anyToErrorObject, _errorLikeToErrorObject } from '../error/error.util';
 import { HttpRequestError } from '../error/httpRequestError';
 import { _clamp } from '../number/number.util';
@@ -96,10 +97,27 @@ export class Fetcher {
         }
         return res.body;
     }
+    /**
+     * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
+     * err, if defined, is strictly HttpRequestError.
+     * UPD: actually not, err is typed as Error, as it feels unsafe to guarantee error type.
+     * UPD: actually yes - it will return HttpRequestError, and throw if there's an error
+     * of any other type.
+     */
+    async tryFetch(opt) {
+        const res = await this.doFetch(opt);
+        if (res.err) {
+            _assertErrorClassOrRethrow(res.err, HttpRequestError);
+            return [res.err, null];
+        }
+        return [null, res.body];
+    }
     /**
      * Returns FetcherResponse.
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
+     *
+     * Note: responseType defaults to `void`, so, override it if you expect different.
      */
     async doFetch(opt) {
         var _a, _b;
@@ -146,7 +164,7 @@ export class Fetcher {
                 }
             }
             try {
-                res.fetchResponse = await this.callNativeFetch(req.fullUrl, req.init);
+                res.fetchResponse = await Fetcher.callNativeFetch(req.fullUrl, req.init);
                 res.ok = res.fetchResponse.ok;
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.err = undefined;
@@ -250,8 +268,9 @@ export class Fetcher {
     }
     /**
      * This method exists to be able to easily mock it.
+     * It is static, so mocking applies to ALL instances (even future ones) of Fetcher at once.
      */
-    async callNativeFetch(url, init) {
+    static async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
     async onNotOkResponse(res) {
@@ -269,6 +288,11 @@ export class Fetcher {
                 cause = _anyToErrorObject(body);
             }
         }
+        cause || (cause = {
+            name: 'Error',
+            message: 'Fetch failed',
+            data: {},
+        });
         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,
@@ -431,7 +455,7 @@ export class Fetcher {
         const norm = _merge({
             baseUrl: '',
             inputUrl: '',
-            responseType: 'void',
+            responseType: 'json',
             searchParams: {},
             timeoutSeconds: 30,
             retryPost: false,

package/package.json

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

package/readme.md

@@ -4,7 +4,7 @@
 
 [![npm](https://img.shields.io/npm/v/@naturalcycles/js-lib/latest.svg)](https://www.npmjs.com/package/@naturalcycles/js-lib)
 [![min.gz size](https://badgen.net/bundlephobia/minzip/@naturalcycles/js-lib)](https://bundlephobia.com/result?p=@naturalcycles/js-lib)
-[![Actions](https://github.com/NaturalCycles/js-lib/workflows/default/badge.svg)](https://github.com/NaturalCycles/js-lib/actions)
+[![Actions](https://github.com/NaturalCycles/js-lib/workflows/ci/badge.svg)](https://github.com/NaturalCycles/js-lib/actions)
 [![loc](https://badgen.net/codeclimate/loc/NaturalCycles/js-lib)](https://github.com/NaturalCycles/js-lib)
 [![Maintainability](https://api.codeclimate.com/v1/badges/c2dc8d53bd79f79b1d8b/maintainability)](https://codeclimate.com/github/NaturalCycles/js-lib/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/c2dc8d53bd79f79b1d8b/test_coverage)](https://codeclimate.com/github/NaturalCycles/js-lib/test_coverage)

package/src/error/assert.ts

@@ -102,6 +102,21 @@ export function _assertIsError<ERR extends Error = Error>(
   }
 }
 
+/**
+ * Asserts that passed object is indeed an Error of defined ErrorClass.
+ * If yes - returns peacefully (with TypeScript assertion).
+ * In not - throws (re-throws) that error up.
+ */
+export function _assertErrorClassOrRethrow<ERR extends Error>(
+  err: any,
+  errorClass: Class<ERR>,
+): asserts err is ERR {
+  if (!(err instanceof errorClass)) {
+    // re-throw
+    throw err
+  }
+}
+
 export function _assertIsErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   obj: any,
 ): asserts obj is ErrorObject<DATA_TYPE> {

package/src/error/httpRequestError.ts

@@ -19,7 +19,14 @@ import type { ErrorObject, HttpRequestErrorData } from './error.model'
  * (by default).
  */
 export class HttpRequestError extends AppError<HttpRequestErrorData> {
-  constructor(message: string, data: HttpRequestErrorData, cause?: ErrorObject) {
+  constructor(message: string, data: HttpRequestErrorData, cause: ErrorObject) {
     super(message, data, cause, 'HttpRequestError')
   }
+
+  /**
+   * Cause is strictly-defined for HttpRequestError,
+   * so it always has a cause.
+   * (for dev convenience)
+   */
+  override cause!: ErrorObject
 }

package/src/error/try.ts

@@ -1,7 +1,8 @@
 import { _stringifyAny } from '../string/stringifyAny'
 import type { Class } from '../typeFest'
-import type { AnyFunction } from '../types'
+import type { AnyFunction, ErrorDataTuple } from '../types'
 import { AppError } from './app.error'
+import { _assertErrorClassOrRethrow } from './assert'
 
 /**
  * Calls a function, returns a Tuple of [error, value].
@@ -10,9 +11,6 @@ import { AppError } from './app.error'
  *
  * Similar to pTry, but for sync functions.
  *
- * For convenience, second argument type is non-optional,
- * so you can use it without `!`. But you SHOULD always check `if (err)` first!
- *
  * ERR is typed as Error, not `unknown`. While unknown would be more correct,
  * according to recent TypeScript, Error gives more developer convenience.
  * In our code we NEVER throw non-errors.
@@ -25,29 +23,35 @@ import { AppError } from './app.error'
  * if (err) ...do something...
  * v // go ahead and use v
  */
-export function _try<ERR = Error, RETURN = void>(
-  fn: () => RETURN,
-): [err: ERR | null, value: RETURN] {
+export function _try<T, ERR extends Error = Error>(
+  fn: () => T,
+  errorClass?: Class<ERR>,
+): ErrorDataTuple<T, ERR> {
   try {
     return [null, fn()]
   } catch (err) {
-    return [err as ERR, undefined as any]
+    if (errorClass) {
+      _assertErrorClassOrRethrow(err, errorClass)
+    }
+
+    return [err as ERR, null]
   }
 }
 
 /**
  * Like _try, but for Promises.
- *
- * Also, intentionally types second return item as non-optional,
- * but you should check for `err` presense first!
  */
-export async function pTry<ERR = Error, RETURN = void>(
-  promise: Promise<RETURN>,
-): Promise<[err: ERR | null, value: Awaited<RETURN>]> {
+export async function pTry<T, ERR extends Error = Error>(
+  promise: Promise<T>,
+  errorClass?: Class<ERR>,
+): Promise<ErrorDataTuple<Awaited<T>, ERR>> {
   try {
     return [null, await promise]
   } catch (err) {
-    return [err as ERR, undefined as any]
+    if (errorClass) {
+      _assertErrorClassOrRethrow(err, errorClass)
+    }
+    return [err as ERR, null]
   }
 }
 
@@ -122,5 +126,17 @@ export async function pExpectedErrorString<ERR = Error>(
   promise: Promise<any>,
   errorClass?: Class<ERR>,
 ): Promise<string> {
-  return _stringifyAny(await pExpectedError<ERR>(promise, errorClass))
+  const err = await pExpectedError<ERR>(promise, errorClass)
+  return _stringifyAny(err)
+}
+
+/**
+ * Shortcut function to simplify error snapshot-matching in tests.
+ */
+export function _expectedErrorString<ERR = Error>(
+  fn: AnyFunction,
+  errorClass?: Class<ERR>,
+): string {
+  const err = _expectedError<ERR>(fn, errorClass)
+  return _stringifyAny(err)
 }

package/src/http/fetcher.model.ts

@@ -186,7 +186,7 @@ export interface FetcherOptions {
   // init?: Partial<RequestInitNormalized>
 
   headers?: Record<string, any>
-  responseType?: FetcherResponseType // default to 'void'
+  responseType?: FetcherResponseType // default to 'json'
 
   searchParams?: Record<string, any>
 

package/src/http/fetcher.ts

@@ -2,6 +2,7 @@
 /// <reference lib="dom.iterable"/>
 
 import { isServerSide } from '../env'
+import { _assertErrorClassOrRethrow } from '../error/assert'
 import { ErrorLike, ErrorObject } from '../error/error.model'
 import { _anyToError, _anyToErrorObject, _errorLikeToErrorObject } from '../error/error.util'
 import { HttpRequestError } from '../error/httpRequestError'
@@ -19,7 +20,7 @@ import { pTimeout, TimeoutError } from '../promise/pTimeout'
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util'
 import { _stringifyAny } from '../string/stringifyAny'
 import { _ms, _since } from '../time/time.util'
-import { NumberOfMilliseconds } from '../types'
+import { ErrorDataTuple, NumberOfMilliseconds } from '../types'
 import type {
   FetcherAfterResponseHook,
   FetcherBeforeRequestHook,
@@ -31,6 +32,7 @@ import type {
   FetcherResponse,
   FetcherResponseType,
   FetcherRetryOptions,
+  RequestInitNormalized,
 } from './fetcher.model'
 import { HTTP_METHODS } from './http.model'
 import type { HttpStatusFamily } from './http.model'
@@ -169,10 +171,28 @@ export class Fetcher {
     return res.body
   }
 
+  /**
+   * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
+   * err, if defined, is strictly HttpRequestError.
+   * UPD: actually not, err is typed as Error, as it feels unsafe to guarantee error type.
+   * UPD: actually yes - it will return HttpRequestError, and throw if there's an error
+   * of any other type.
+   */
+  async tryFetch<T = unknown>(opt: FetcherOptions): Promise<ErrorDataTuple<T, HttpRequestError>> {
+    const res = await this.doFetch<T>(opt)
+    if (res.err) {
+      _assertErrorClassOrRethrow(res.err, HttpRequestError)
+      return [res.err, null]
+    }
+    return [null, res.body]
+  }
+
   /**
    * Returns FetcherResponse.
    * Never throws, returns `err` property in the response instead.
    * Use this method instead of `throwHttpErrors: false` or try-catching.
+   *
+   * Note: responseType defaults to `void`, so, override it if you expect different.
    */
   async doFetch<T = unknown>(opt: FetcherOptions): Promise<FetcherResponse<T>> {
     const req = this.normalizeOptions(opt)
@@ -230,7 +250,7 @@ export class Fetcher {
       }
 
       try {
-        res.fetchResponse = await this.callNativeFetch(req.fullUrl, req.init)
+        res.fetchResponse = await Fetcher.callNativeFetch(req.fullUrl, req.init)
         res.ok = res.fetchResponse.ok
         // important to set it to undefined, otherwise it can keep the previous value (from previous try)
         res.err = undefined
@@ -343,13 +363,14 @@ export class Fetcher {
 
   /**
    * This method exists to be able to easily mock it.
+   * It is static, so mocking applies to ALL instances (even future ones) of Fetcher at once.
    */
-  async callNativeFetch(url: string, init: RequestInit): Promise<Response> {
+  static async callNativeFetch(url: string, init: RequestInitNormalized): Promise<Response> {
     return await globalThis.fetch(url, init)
   }
 
   private async onNotOkResponse(res: FetcherResponse): Promise<void> {
-    let cause: ErrorObject | undefined
+    let cause: ErrorObject
 
     if (res.err) {
       // This is only possible on JSON.parse error, or CORS error,
@@ -363,6 +384,12 @@ export class Fetcher {
       }
     }
 
+    cause ||= {
+      name: 'Error',
+      message: 'Fetch failed',
+      data: {},
+    }
+
     const message = [res.fetchResponse?.status, res.signature].filter(Boolean).join(' ')
 
     res.err = new HttpRequestError(
@@ -545,7 +572,7 @@ export class Fetcher {
       {
         baseUrl: '',
         inputUrl: '',
-        responseType: 'void',
+        responseType: 'json',
         searchParams: {},
         timeoutSeconds: 30,
         retryPost: false,

package/src/types.ts

@@ -278,3 +278,15 @@ export const _objectAssign = Object.assign as <T extends AnyObject>(
   target: T,
   part: Partial<T>,
 ) => T
+
+/**
+ * Defines a tuple of [err, data]
+ * where only 1 of them exists.
+ * Either error exists and data is null
+ * Or error is null and data is defined.
+ * This forces you to check `if (err)`, which lets
+ * TypeScript infer the existence of `data`.
+ *
+ * Functions like pTry use that.
+ */
+export type ErrorDataTuple<T = unknown, ERR = Error> = [err: null, data: T] | [err: ERR, data: null]