@naturalcycles/js-lib 14.157.0 → 14.157.1

package/dist/http/fetcher.js

@@ -121,19 +121,6 @@ class Fetcher {
         const req = this.normalizeOptions(opt);
         const { logger } = this.cfg;
         const { timeoutSeconds, init: { method }, } = req;
-        // setup timeout
-        let timeout;
-        if (timeoutSeconds) {
-            const abortController = new AbortController();
-            req.init.signal = abortController.signal;
-            timeout = setTimeout(() => {
-                // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
-                // so, we're wrapping it in a TimeoutError instance
-                abortController.abort(new pTimeout_1.TimeoutError(`request timed out after ${timeoutSeconds} sec`));
-                // abortController.abort(`timeout of ${timeoutSeconds} sec`)
-                // abortController.abort()
-            }, timeoutSeconds * 1000);
-        }
         for (const hook of this.cfg.hooks.beforeRequest || []) {
             await hook(req);
         }
@@ -152,6 +139,18 @@ class Fetcher {
         };
         while (!res.retryStatus.retryStopped) {
             req.started = Date.now();
+            // setup timeout
+            let timeoutId;
+            if (timeoutSeconds) {
+                const abortController = new AbortController();
+                req.init.signal = abortController.signal;
+                timeoutId = setTimeout(() => {
+                    // console.log(`actual request timed out in ${_since(req.started)}`)
+                    // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
+                    // so, we're wrapping it in a TimeoutError instance
+                    abortController.abort(new pTimeout_1.TimeoutError(`request timed out after ${timeoutSeconds} sec`));
+                }, timeoutSeconds * 1000);
+            }
             if (this.cfg.logRequest) {
                 const { retryAttempt } = res.retryStatus;
                 logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
@@ -175,14 +174,30 @@ class Fetcher {
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.fetchResponse = undefined;
             }
+            finally {
+                clearTimeout(timeoutId);
+                // Separate Timeout will be introduced to "download and parse the body"
+            }
             res.statusFamily = this.getStatusFamily(res);
             res.statusCode = res.fetchResponse?.status;
             if (res.fetchResponse?.ok) {
-                await this.onOkResponse(res, timeout);
+                try {
+                    // 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',
+                    });
+                }
+                catch (err) {
+                    // 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;
+                    await this.onNotOkResponse(res);
+                }
             }
             else {
                 // !res.ok
-                await this.onNotOkResponse(res, timeout);
+                await this.onNotOkResponse(res);
             }
         }
         for (const hook of this.cfg.hooks.afterResponse || []) {
@@ -190,31 +205,17 @@ class Fetcher {
         }
         return res;
     }
-    async onOkResponse(res, timeout) {
+    async onOkResponse(res) {
         const { req } = res;
         const { responseType } = res.req;
+        // This function is subject to a separate timeout to "download and parse the data"
         if (responseType === 'json') {
             if (res.fetchResponse.body) {
                 const text = await res.fetchResponse.text();
                 if (text) {
-                    try {
-                        res.body = text;
-                        res.body = (0, json_util_1._jsonParse)(text, req.jsonReviver);
-                    }
-                    catch (err) {
-                        // 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, timeout);
-                    }
+                    res.body = text;
+                    res.body = (0, json_util_1._jsonParse)(text, req.jsonReviver);
+                    // Error while parsing json can happen - it'll be handled upstream
                 }
                 else {
                     // Body had a '' (empty string)
@@ -239,12 +240,10 @@ class Fetcher {
         else if (responseType === 'readableStream') {
             res.body = res.fetchResponse.body;
             if (res.body === null) {
-                res.err = new Error(`fetchResponse.body is null`);
-                res.ok = false;
-                return await this.onNotOkResponse(res, timeout);
+                // Error is to be handled upstream
+                throw new Error(`fetchResponse.body is null`);
             }
         }
-        clearTimeout(timeout);
         res.retryStatus.retryStopped = true;
         // res.err can happen on `failed to fetch` type of error, e.g JSON.parse, CORS, unexpected redirect
         if (!res.err && this.cfg.logResponse) {
@@ -270,8 +269,7 @@ class Fetcher {
     async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
-    async onNotOkResponse(res, timeout) {
-        clearTimeout(timeout);
+    async onNotOkResponse(res) {
         let cause;
         if (res.err) {
             // This is only possible on JSON.parse error, or CORS error,
@@ -337,7 +335,11 @@ class Fetcher {
             return;
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = (0, number_util_1._clamp)(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
-        await (0, pDelay_1.pDelay)(this.getRetryTimeout(res));
+        const timeout = this.getRetryTimeout(res);
+        if (res.req.debug) {
+            this.cfg.logger.log(` .. ${res.signature} waiting ${(0, time_util_1._ms)(timeout)}`);
+        }
+        await (0, pDelay_1.pDelay)(timeout);
     }
     getRetryTimeout(res) {
         let timeout = 0;
@@ -392,8 +394,9 @@ class Fetcher {
         if (statusFamily === 3 && !retry3xx)
             return false;
         // should not retry on `unexpected redirect` in error.cause.cause
-        if (res.err?.cause?.cause?.message?.includes('unexpected redirect'))
+        if (res.err?.cause?.cause?.message?.includes('unexpected redirect')) {
             return false;
+        }
         return true; // default is true
     }
     getStatusFamily(res) {
@@ -431,7 +434,7 @@ class Fetcher {
     }
     normalizeCfg(cfg) {
         if (cfg.baseUrl?.endsWith('/')) {
-            console.warn(`Fetcher: baseUrl should not end with /`);
+            console.warn(`Fetcher: baseUrl should not end with slash: ${cfg.baseUrl}`);
             cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1);
         }
         const { debug = false } = cfg;
@@ -482,6 +485,7 @@ class Fetcher {
                 'logRequestBody',
                 'logResponse',
                 'logResponseBody',
+                'debug',
             ]),
             started: Date.now(),
             ...(0, object_util_1._omit)(opt, ['method', 'headers', 'credentials']),

package/dist/http/fetcher.model.d.ts

@@ -1,8 +1,8 @@
 import type { CommonLogger } from '../log/commonLogger';
 import type { Promisable } from '../typeFest';
-import type { AnyObject, Reviver, UnixTimestampMillisNumber } from '../types';
+import type { AnyObject, NumberOfMilliseconds, Reviver, UnixTimestampMillisNumber } from '../types';
 import type { HttpMethod, HttpStatusFamily } from './http.model';
-export interface FetcherNormalizedCfg extends Required<FetcherCfg>, Omit<FetcherRequest, 'started' | 'fullUrl' | 'logRequest' | 'logRequestBody' | 'logResponse' | 'logResponseBody' | 'redirect' | 'credentials'> {
+export interface FetcherNormalizedCfg extends Required<FetcherCfg>, Omit<FetcherRequest, 'started' | 'fullUrl' | 'logRequest' | 'logRequestBody' | 'logResponse' | 'logResponseBody' | 'debug' | 'redirect' | 'credentials'> {
     logger: CommonLogger;
     searchParams: Record<string, any>;
 }
@@ -68,13 +68,13 @@ export interface FetcherCfg {
 }
 export interface FetcherRetryStatus {
     retryAttempt: number;
-    retryTimeout: number;
+    retryTimeout: NumberOfMilliseconds;
     retryStopped: boolean;
 }
 export interface FetcherRetryOptions {
     count: number;
-    timeout: number;
-    timeoutMax: number;
+    timeout: NumberOfMilliseconds;
+    timeoutMax: NumberOfMilliseconds;
     timeoutMultiplier: number;
 }
 export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl' | 'url'> {
@@ -172,6 +172,10 @@ export interface FetcherOptions {
     logRequestBody?: boolean;
     logResponse?: boolean;
     logResponseBody?: boolean;
+    /**
+     * If true - enables all possible logging.
+     */
+    debug?: boolean;
 }
 export type RequestInitNormalized = Omit<RequestInit, 'method' | 'headers'> & {
     method: HttpMethod;

package/dist/promise/pTimeout.d.ts

@@ -1,6 +1,6 @@
 import { AppError } from '../error/app.error';
 import type { ErrorData, ErrorObject } from '../error/error.model';
-import type { AnyAsyncFunction } from '../types';
+import type { AnyAsyncFunction, NumberOfMilliseconds } from '../types';
 export declare class TimeoutError extends AppError {
     constructor(message: string, data?: {}, cause?: ErrorObject);
 }
@@ -8,7 +8,7 @@ export interface PTimeoutOptions {
     /**
      * Timeout in milliseconds.
      */
-    timeout: number;
+    timeout: NumberOfMilliseconds;
     /**
      * If set - will be included in the error message.
      * Can be used to identify the place in the code that failed.

package/dist-esm/http/fetcher.js

@@ -6,10 +6,10 @@ import { HttpRequestError } from '../error/httpRequestError';
 import { _clamp } from '../number/number.util';
 import { _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, _pick, } from '../object/object.util';
 import { pDelay } from '../promise/pDelay';
-import { TimeoutError } from '../promise/pTimeout';
+import { pTimeout, TimeoutError } from '../promise/pTimeout';
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util';
 import { _stringifyAny } from '../string/stringifyAny';
-import { _since } from '../time/time.util';
+import { _ms, _since } from '../time/time.util';
 import { HTTP_METHODS } from './http.model';
 const acceptByResponseType = {
     text: 'text/plain',
@@ -106,19 +106,6 @@ export class Fetcher {
         const req = this.normalizeOptions(opt);
         const { logger } = this.cfg;
         const { timeoutSeconds, init: { method }, } = req;
-        // setup timeout
-        let timeout;
-        if (timeoutSeconds) {
-            const abortController = new AbortController();
-            req.init.signal = abortController.signal;
-            timeout = setTimeout(() => {
-                // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
-                // so, we're wrapping it in a TimeoutError instance
-                abortController.abort(new TimeoutError(`request timed out after ${timeoutSeconds} sec`));
-                // abortController.abort(`timeout of ${timeoutSeconds} sec`)
-                // abortController.abort()
-            }, timeoutSeconds * 1000);
-        }
         for (const hook of this.cfg.hooks.beforeRequest || []) {
             await hook(req);
         }
@@ -137,6 +124,18 @@ export class Fetcher {
         };
         while (!res.retryStatus.retryStopped) {
             req.started = Date.now();
+            // setup timeout
+            let timeoutId;
+            if (timeoutSeconds) {
+                const abortController = new AbortController();
+                req.init.signal = abortController.signal;
+                timeoutId = setTimeout(() => {
+                    // console.log(`actual request timed out in ${_since(req.started)}`)
+                    // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
+                    // so, we're wrapping it in a TimeoutError instance
+                    abortController.abort(new TimeoutError(`request timed out after ${timeoutSeconds} sec`));
+                }, timeoutSeconds * 1000);
+            }
             if (this.cfg.logRequest) {
                 const { retryAttempt } = res.retryStatus;
                 logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
@@ -160,14 +159,30 @@ export class Fetcher {
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.fetchResponse = undefined;
             }
+            finally {
+                clearTimeout(timeoutId);
+                // Separate Timeout will be introduced to "download and parse the body"
+            }
             res.statusFamily = this.getStatusFamily(res);
             res.statusCode = (_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status;
             if ((_b = res.fetchResponse) === null || _b === void 0 ? void 0 : _b.ok) {
-                await this.onOkResponse(res, timeout);
+                try {
+                    // 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',
+                    });
+                }
+                catch (err) {
+                    // onOkResponse can still fail, e.g when loading/parsing json, text or doing other response manipulation
+                    res.err = _anyToError(err);
+                    res.ok = false;
+                    await this.onNotOkResponse(res);
+                }
             }
             else {
                 // !res.ok
-                await this.onNotOkResponse(res, timeout);
+                await this.onNotOkResponse(res);
             }
         }
         for (const hook of this.cfg.hooks.afterResponse || []) {
@@ -175,31 +190,17 @@ export class Fetcher {
         }
         return res;
     }
-    async onOkResponse(res, timeout) {
+    async onOkResponse(res) {
         const { req } = res;
         const { responseType } = res.req;
+        // This function is subject to a separate timeout to "download and parse the data"
         if (responseType === 'json') {
             if (res.fetchResponse.body) {
                 const text = await res.fetchResponse.text();
                 if (text) {
-                    try {
-                        res.body = text;
-                        res.body = _jsonParse(text, req.jsonReviver);
-                    }
-                    catch (err) {
-                        // Error while parsing json
-                        // res.err = _anyToError(err, HttpRequestError, {
-                        //   requestUrl: res.req.url,
-                        //   requestBaseUrl: this.cfg.baseUrl,
-                        //   requestMethod: res.req.init.method,
-                        //   requestSignature: res.signature,
-                        //   requestDuration: Date.now() - started,
-                        //   responseStatusCode: res.fetchResponse.status,
-                        // } satisfies HttpRequestErrorData)
-                        res.err = _anyToError(err);
-                        res.ok = false;
-                        return await this.onNotOkResponse(res, timeout);
-                    }
+                    res.body = text;
+                    res.body = _jsonParse(text, req.jsonReviver);
+                    // Error while parsing json can happen - it'll be handled upstream
                 }
                 else {
                     // Body had a '' (empty string)
@@ -224,12 +225,10 @@ export class Fetcher {
         else if (responseType === 'readableStream') {
             res.body = res.fetchResponse.body;
             if (res.body === null) {
-                res.err = new Error(`fetchResponse.body is null`);
-                res.ok = false;
-                return await this.onNotOkResponse(res, timeout);
+                // Error is to be handled upstream
+                throw new Error(`fetchResponse.body is null`);
             }
         }
-        clearTimeout(timeout);
         res.retryStatus.retryStopped = true;
         // res.err can happen on `failed to fetch` type of error, e.g JSON.parse, CORS, unexpected redirect
         if (!res.err && this.cfg.logResponse) {
@@ -255,9 +254,8 @@ export class Fetcher {
     async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
-    async onNotOkResponse(res, timeout) {
+    async onNotOkResponse(res) {
         var _a, _b;
-        clearTimeout(timeout);
         let cause;
         if (res.err) {
             // This is only possible on JSON.parse error, or CORS error,
@@ -324,7 +322,11 @@ export class Fetcher {
             return;
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
-        await pDelay(this.getRetryTimeout(res));
+        const timeout = this.getRetryTimeout(res);
+        if (res.req.debug) {
+            this.cfg.logger.log(` .. ${res.signature} waiting ${_ms(timeout)}`);
+        }
+        await pDelay(timeout);
     }
     getRetryTimeout(res) {
         var _a;
@@ -380,8 +382,9 @@ export class Fetcher {
         if (statusFamily === 3 && !retry3xx)
             return false;
         // should not retry on `unexpected redirect` in error.cause.cause
-        if ((_e = (_d = (_c = (_b = res.err) === null || _b === void 0 ? void 0 : _b.cause) === null || _c === void 0 ? void 0 : _c.cause) === null || _d === void 0 ? void 0 : _d.message) === null || _e === void 0 ? void 0 : _e.includes('unexpected redirect'))
+        if ((_e = (_d = (_c = (_b = res.err) === null || _b === void 0 ? void 0 : _b.cause) === null || _c === void 0 ? void 0 : _c.cause) === null || _d === void 0 ? void 0 : _d.message) === null || _e === void 0 ? void 0 : _e.includes('unexpected redirect')) {
             return false;
+        }
         return true; // default is true
     }
     getStatusFamily(res) {
@@ -421,7 +424,7 @@ export class Fetcher {
     normalizeCfg(cfg) {
         var _a;
         if ((_a = cfg.baseUrl) === null || _a === void 0 ? void 0 : _a.endsWith('/')) {
-            console.warn(`Fetcher: baseUrl should not end with /`);
+            console.warn(`Fetcher: baseUrl should not end with slash: ${cfg.baseUrl}`);
             cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1);
         }
         const { debug = false } = cfg;
@@ -469,6 +472,7 @@ export class Fetcher {
             'logRequestBody',
             'logResponse',
             'logResponseBody',
+            'debug',
         ])), { started: Date.now() }), _omit(opt, ['method', 'headers', 'credentials'])), { inputUrl: opt.url || '', fullUrl: opt.url || '', retry: Object.assign(Object.assign({}, this.cfg.retry), _filterUndefinedValues(opt.retry || {})), init: _merge(Object.assign(Object.assign({}, this.cfg.init), { method: opt.method || this.cfg.init.method, credentials: opt.credentials || this.cfg.init.credentials, redirect: opt.redirect || this.cfg.init.redirect || 'follow' }), {
                 headers: _mapKeys(opt.headers || {}, k => k.toLowerCase()),
             }) });

package/package.json

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

package/src/http/fetcher.model.ts

@@ -1,6 +1,6 @@
 import type { CommonLogger } from '../log/commonLogger'
 import type { Promisable } from '../typeFest'
-import type { AnyObject, Reviver, UnixTimestampMillisNumber } from '../types'
+import type { AnyObject, NumberOfMilliseconds, Reviver, UnixTimestampMillisNumber } from '../types'
 import type { HttpMethod, HttpStatusFamily } from './http.model'
 
 export interface FetcherNormalizedCfg
@@ -13,6 +13,7 @@ export interface FetcherNormalizedCfg
       | 'logRequestBody'
       | 'logResponse'
       | 'logResponseBody'
+      | 'debug'
       | 'redirect'
       | 'credentials'
     > {
@@ -93,14 +94,14 @@ export interface FetcherCfg {
 
 export interface FetcherRetryStatus {
   retryAttempt: number
-  retryTimeout: number
+  retryTimeout: NumberOfMilliseconds
   retryStopped: boolean
 }
 
 export interface FetcherRetryOptions {
   count: number
-  timeout: number
-  timeoutMax: number
+  timeout: NumberOfMilliseconds
+  timeoutMax: NumberOfMilliseconds
   timeoutMultiplier: number
 }
 
@@ -219,6 +220,10 @@ export interface FetcherOptions {
   logRequestBody?: boolean
   logResponse?: boolean
   logResponseBody?: boolean
+  /**
+   * If true - enables all possible logging.
+   */
+  debug?: boolean
 }
 
 export type RequestInitNormalized = Omit<RequestInit, 'method' | 'headers'> & {

package/src/http/fetcher.ts

@@ -15,10 +15,10 @@ import {
   _pick,
 } from '../object/object.util'
 import { pDelay } from '../promise/pDelay'
-import { TimeoutError } from '../promise/pTimeout'
+import { pTimeout, TimeoutError } from '../promise/pTimeout'
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util'
 import { _stringifyAny } from '../string/stringifyAny'
-import { _since } from '../time/time.util'
+import { _ms, _since } from '../time/time.util'
 import { NumberOfMilliseconds } from '../types'
 import type {
   FetcherAfterResponseHook,
@@ -182,20 +182,6 @@ export class Fetcher {
       init: { method },
     } = req
 
-    // setup timeout
-    let timeout: number | undefined
-    if (timeoutSeconds) {
-      const abortController = new AbortController()
-      req.init.signal = abortController.signal
-      timeout = setTimeout(() => {
-        // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
-        // so, we're wrapping it in a TimeoutError instance
-        abortController.abort(new TimeoutError(`request timed out after ${timeoutSeconds} sec`))
-        // abortController.abort(`timeout of ${timeoutSeconds} sec`)
-        // abortController.abort()
-      }, timeoutSeconds * 1000) as any as number
-    }
-
     for (const hook of this.cfg.hooks.beforeRequest || []) {
       await hook(req)
     }
@@ -218,6 +204,19 @@ export class Fetcher {
     while (!res.retryStatus.retryStopped) {
       req.started = Date.now()
 
+      // setup timeout
+      let timeoutId: number | undefined
+      if (timeoutSeconds) {
+        const abortController = new AbortController()
+        req.init.signal = abortController.signal
+        timeoutId = setTimeout(() => {
+          // console.log(`actual request timed out in ${_since(req.started)}`)
+          // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
+          // so, we're wrapping it in a TimeoutError instance
+          abortController.abort(new TimeoutError(`request timed out after ${timeoutSeconds} sec`))
+        }, timeoutSeconds * 1000) as any as number
+      }
+
       if (this.cfg.logRequest) {
         const { retryAttempt } = res.retryStatus
         logger.log(
@@ -242,15 +241,33 @@ export class Fetcher {
         res.ok = false
         // important to set it to undefined, otherwise it can keep the previous value (from previous try)
         res.fetchResponse = undefined
+      } finally {
+        clearTimeout(timeoutId)
+        // Separate Timeout will be introduced to "download and parse the body"
       }
       res.statusFamily = this.getStatusFamily(res)
       res.statusCode = res.fetchResponse?.status
 
       if (res.fetchResponse?.ok) {
-        await this.onOkResponse(res as FetcherResponse<T> & { fetchResponse: Response }, timeout)
+        try {
+          // 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 as FetcherResponse<T> & { fetchResponse: Response }),
+            {
+              timeout: timeoutSeconds * 1000 || Number.POSITIVE_INFINITY,
+              name: 'Fetcher.onOkResponse',
+            },
+          )
+        } catch (err) {
+          // onOkResponse can still fail, e.g when loading/parsing json, text or doing other response manipulation
+          res.err = _anyToError(err)
+          res.ok = false
+          await this.onNotOkResponse(res)
+        }
       } else {
         // !res.ok
-        await this.onNotOkResponse(res, timeout)
+        await this.onNotOkResponse(res)
       }
     }
 
@@ -263,34 +280,19 @@ export class Fetcher {
 
   private async onOkResponse(
     res: FetcherResponse<any> & { fetchResponse: Response },
-    timeout?: number,
   ): Promise<void> {
     const { req } = res
     const { responseType } = res.req
 
+    // This function is subject to a separate timeout to "download and parse the data"
     if (responseType === 'json') {
       if (res.fetchResponse.body) {
         const text = await res.fetchResponse.text()
 
         if (text) {
-          try {
-            res.body = text
-            res.body = _jsonParse(text, req.jsonReviver)
-          } catch (err) {
-            // Error while parsing json
-            // res.err = _anyToError(err, HttpRequestError, {
-            //   requestUrl: res.req.url,
-            //   requestBaseUrl: this.cfg.baseUrl,
-            //   requestMethod: res.req.init.method,
-            //   requestSignature: res.signature,
-            //   requestDuration: Date.now() - started,
-            //   responseStatusCode: res.fetchResponse.status,
-            // } satisfies HttpRequestErrorData)
-            res.err = _anyToError(err)
-            res.ok = false
-
-            return await this.onNotOkResponse(res, timeout)
-          }
+          res.body = text
+          res.body = _jsonParse(text, req.jsonReviver)
+          // Error while parsing json can happen - it'll be handled upstream
         } else {
           // Body had a '' (empty string)
           res.body = {}
@@ -310,13 +312,11 @@ export class Fetcher {
       res.body = res.fetchResponse.body
 
       if (res.body === null) {
-        res.err = new Error(`fetchResponse.body is null`)
-        res.ok = false
-        return await this.onNotOkResponse(res, timeout)
+        // Error is to be handled upstream
+        throw new Error(`fetchResponse.body is null`)
       }
     }
 
-    clearTimeout(timeout)
     res.retryStatus.retryStopped = true
 
     // res.err can happen on `failed to fetch` type of error, e.g JSON.parse, CORS, unexpected redirect
@@ -348,9 +348,7 @@ export class Fetcher {
     return await globalThis.fetch(url, init)
   }
 
-  private async onNotOkResponse(res: FetcherResponse, timeout?: number): Promise<void> {
-    clearTimeout(timeout)
-
+  private async onNotOkResponse(res: FetcherResponse): Promise<void> {
     let cause: ErrorObject | undefined
 
     if (res.err) {
@@ -433,7 +431,11 @@ export class Fetcher {
     retryStatus.retryAttempt++
     retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax)
 
-    await pDelay(this.getRetryTimeout(res))
+    const timeout = this.getRetryTimeout(res)
+    if (res.req.debug) {
+      this.cfg.logger.log(` .. ${res.signature} waiting ${_ms(timeout)}`)
+    }
+    await pDelay(timeout)
   }
 
   private getRetryTimeout(res: FetcherResponse): NumberOfMilliseconds {
@@ -491,8 +493,9 @@ export class Fetcher {
     if (statusFamily === 3 && !retry3xx) return false
 
     // should not retry on `unexpected redirect` in error.cause.cause
-    if ((res.err?.cause as ErrorLike | void)?.cause?.message?.includes('unexpected redirect'))
+    if ((res.err?.cause as ErrorLike | void)?.cause?.message?.includes('unexpected redirect')) {
       return false
+    }
 
     return true // default is true
   }
@@ -533,7 +536,7 @@ export class Fetcher {
 
   private normalizeCfg(cfg: FetcherCfg & FetcherOptions): FetcherNormalizedCfg {
     if (cfg.baseUrl?.endsWith('/')) {
-      console.warn(`Fetcher: baseUrl should not end with /`)
+      console.warn(`Fetcher: baseUrl should not end with slash: ${cfg.baseUrl}`)
       cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1)
     }
     const { debug = false } = cfg
@@ -591,6 +594,7 @@ export class Fetcher {
         'logRequestBody',
         'logResponse',
         'logResponseBody',
+        'debug',
       ]),
       started: Date.now(),
       ..._omit(opt, ['method', 'headers', 'credentials']),

package/src/promise/pTimeout.ts

@@ -1,7 +1,7 @@
 import { AppError } from '../error/app.error'
 import type { ErrorData, ErrorObject } from '../error/error.model'
 import { _errorDataAppend } from '../error/error.util'
-import type { AnyAsyncFunction } from '../types'
+import type { AnyAsyncFunction, NumberOfMilliseconds } from '../types'
 
 export class TimeoutError extends AppError {
   constructor(message: string, data = {}, cause?: ErrorObject) {
@@ -13,7 +13,7 @@ export interface PTimeoutOptions {
   /**
    * Timeout in milliseconds.
    */
-  timeout: number
+  timeout: NumberOfMilliseconds
 
   /**
    * If set - will be included in the error message.