@naturalcycles/js-lib 14.133.1 → 14.135.0

package/dist/env.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Use it to detect SSR/Node.js environment.
+ *
+ * Will return `true` in Node.js.
+ * Will return `false` in the Browser.
+ */
+export declare function isServerSide(): boolean;
+/**
+ * Use it to detect Browser (not SSR/Node) environment.
+ *
+ * Will return `true` in the Browser.
+ * Will return `false` in Node.js.
+ */
+export declare function isClientSide(): boolean;

package/dist/env.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClientSide = exports.isServerSide = void 0;
+/**
+ * Use it to detect SSR/Node.js environment.
+ *
+ * Will return `true` in Node.js.
+ * Will return `false` in the Browser.
+ */
+function isServerSide() {
+    return typeof window === 'undefined';
+}
+exports.isServerSide = isServerSide;
+/**
+ * Use it to detect Browser (not SSR/Node) environment.
+ *
+ * Will return `true` in the Browser.
+ * Will return `false` in Node.js.
+ */
+function isClientSide() {
+    return typeof window !== 'undefined';
+}
+exports.isClientSide = isClientSide;

package/dist/http/fetcher.d.ts

@@ -38,10 +38,14 @@ export declare class Fetcher {
      * Never throws, returns `err` property in the response instead.
      */
     rawFetch<T = unknown>(url: string, rawOpt?: FetcherOptions): Promise<FetcherResponse<T>>;
+    private onOkResponse;
+    private onNotOkResponse;
     private processRetry;
     /**
      * Default is yes,
      * unless there's reason not to (e.g method is POST).
+     *
+     * statusCode of 0 (or absense of it) will BE retried.
      */
     private shouldRetry;
     private getStatusFamily;

package/dist/http/fetcher.js

@@ -2,6 +2,7 @@
 /// <reference lib="dom"/>
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFetcher = exports.Fetcher = void 0;
+const env_1 = require("../env");
 const error_util_1 = require("../error/error.util");
 const http_error_1 = require("../error/http.error");
 const number_util_1 = require("../number/number.util");
@@ -12,7 +13,7 @@ const time_util_1 = require("../time/time.util");
 const http_model_1 = require("./http.model");
 const defRetryOptions = {
     count: 2,
-    timeout: 500,
+    timeout: 1000,
     timeoutMax: 30000,
     timeoutMultiplier: 2,
 };
@@ -94,7 +95,7 @@ class Fetcher {
     async rawFetch(url, rawOpt = {}) {
         const { logger } = this.cfg;
         const req = this.normalizeOptions(url, rawOpt);
-        const { timeoutSeconds, mode, init: { method }, } = req;
+        const { timeoutSeconds, init: { method }, } = req;
         // setup timeout
         let timeout;
         if (timeoutSeconds) {
@@ -107,6 +108,10 @@ class Fetcher {
         for await (const hook of this.cfg.hooks.beforeRequest || []) {
             await hook(req);
         }
+        const isFullUrl = req.url.includes('://');
+        const fullUrl = isFullUrl ? new URL(req.url) : undefined;
+        const shortUrl = fullUrl ? this.getShortUrl(fullUrl) : req.url;
+        const signature = [method, shortUrl].join(' ');
         const res = {
             req,
             retryStatus: {
@@ -114,10 +119,8 @@ class Fetcher {
                 retryStopped: false,
                 retryTimeout: req.retry.timeout,
             },
+            signature,
         };
-        const fullUrl = new URL(req.url);
-        const shortUrl = this.getShortUrl(fullUrl);
-        const signature = [method, shortUrl].join(' ');
         /* eslint-disable no-await-in-loop */
         while (!res.retryStatus.retryStopped) {
             const started = Date.now();
@@ -141,95 +144,11 @@ class Fetcher {
             }
             res.statusFamily = this.getStatusFamily(res);
             if (res.fetchResponse?.ok) {
-                if (mode === 'json') {
-                    if (res.fetchResponse.body) {
-                        const text = await res.fetchResponse.text();
-                        if (text) {
-                            try {
-                                res.body = text;
-                                res.body = JSON.parse(text, req.jsonReviver);
-                            }
-                            catch (err) {
-                                const { message } = (0, error_util_1._anyToError)(err);
-                                res.err = new http_error_1.HttpError([signature, message].join('\n'), {
-                                    httpStatusCode: 0,
-                                    url: req.url,
-                                });
-                                res.ok = false;
-                            }
-                        }
-                        else {
-                            // Body had a '' (empty string)
-                            res.body = {};
-                        }
-                    }
-                    else {
-                        // if no body: set responseBody as {}
-                        // do not throw a "cannot parse null as Json" error
-                        res.body = {};
-                    }
-                }
-                else if (mode === 'text') {
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
-                }
-                else if (mode === 'arrayBuffer') {
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {};
-                }
-                else if (mode === 'blob') {
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {};
-                }
-                clearTimeout(timeout);
-                res.retryStatus.retryStopped = true;
-                // res.err can happen on JSON.parse error
-                if (!res.err && this.cfg.logResponse) {
-                    const { retryAttempt } = res.retryStatus;
-                    logger.log([
-                        ' <<',
-                        res.fetchResponse.status,
-                        signature,
-                        retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
-                        (0, time_util_1._since)(started),
-                    ]
-                        .filter(Boolean)
-                        .join(' '));
-                    if (this.cfg.logResponseBody) {
-                        logger.log(res.body);
-                    }
-                }
+                await this.onOkResponse(res, started, timeout);
             }
             else {
                 // !res.ok
-                clearTimeout(timeout);
-                let errObj;
-                if (res.fetchResponse) {
-                    const body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
-                    errObj = (0, error_util_1._anyToErrorObject)(body);
-                }
-                else if (res.err) {
-                    errObj = (0, error_util_1._errorToErrorObject)(res.err);
-                }
-                else {
-                    errObj = {};
-                }
-                const originalMessage = errObj.message;
-                errObj.message = [
-                    [res.fetchResponse?.status, signature].filter(Boolean).join(' '),
-                    originalMessage,
-                ]
-                    .filter(Boolean)
-                    .join('\n');
-                res.err = new http_error_1.HttpError(errObj.message, (0, object_util_1._filterNullishValues)({
-                    ...errObj.data,
-                    originalMessage,
-                    httpStatusCode: res.fetchResponse?.status || 0,
-                    // These properties are provided to be used in e.g custom Sentry error grouping
-                    // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
-                    // Enabled, cause `data` is not printed by default when error is HttpError
-                    // method: req.method,
-                    url: req.url,
-                    // tryCount: req.tryCount,
-                }));
-                await this.processRetry(res);
+                await this.onNotOkResponse(res, timeout);
             }
         }
         for await (const hook of this.cfg.hooks.afterResponse || []) {
@@ -237,6 +156,99 @@ class Fetcher {
         }
         return res;
     }
+    async onOkResponse(res, started, timeout) {
+        const { req } = res;
+        const { mode } = res.req;
+        if (mode === 'json') {
+            if (res.fetchResponse.body) {
+                const text = await res.fetchResponse.text();
+                if (text) {
+                    try {
+                        res.body = text;
+                        res.body = JSON.parse(text, req.jsonReviver);
+                    }
+                    catch (err) {
+                        const { message } = (0, error_util_1._anyToError)(err);
+                        res.err = new http_error_1.HttpError([res.signature, message].join('\n'), {
+                            httpStatusCode: 0,
+                            url: req.url,
+                        });
+                        res.ok = false;
+                    }
+                }
+                else {
+                    // Body had a '' (empty string)
+                    res.body = {};
+                }
+            }
+            else {
+                // if no body: set responseBody as {}
+                // do not throw a "cannot parse null as Json" error
+                res.body = {};
+            }
+        }
+        else if (mode === 'text') {
+            res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
+        }
+        else if (mode === 'arrayBuffer') {
+            res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {};
+        }
+        else if (mode === 'blob') {
+            res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {};
+        }
+        clearTimeout(timeout);
+        res.retryStatus.retryStopped = true;
+        // res.err can happen on JSON.parse error
+        if (!res.err && this.cfg.logResponse) {
+            const { retryAttempt } = res.retryStatus;
+            const { logger } = this.cfg;
+            logger.log([
+                ' <<',
+                res.fetchResponse.status,
+                res.signature,
+                retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
+                (0, time_util_1._since)(started),
+            ]
+                .filter(Boolean)
+                .join(' '));
+            if (this.cfg.logResponseBody) {
+                logger.log(res.body);
+            }
+        }
+    }
+    async onNotOkResponse(res, timeout) {
+        clearTimeout(timeout);
+        let errObj;
+        if (res.fetchResponse) {
+            const body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
+            errObj = (0, error_util_1._anyToErrorObject)(body);
+        }
+        else if (res.err) {
+            errObj = (0, error_util_1._errorToErrorObject)(res.err);
+        }
+        else {
+            errObj = {};
+        }
+        const originalMessage = errObj.message;
+        errObj.message = [
+            [res.fetchResponse?.status, res.signature].filter(Boolean).join(' '),
+            originalMessage,
+        ]
+            .filter(Boolean)
+            .join('\n');
+        res.err = new http_error_1.HttpError(errObj.message, (0, object_util_1._filterNullishValues)({
+            ...errObj.data,
+            originalMessage,
+            httpStatusCode: res.fetchResponse?.status || 0,
+            // These properties are provided to be used in e.g custom Sentry error grouping
+            // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
+            // Enabled, cause `data` is not printed by default when error is HttpError
+            // method: req.method,
+            url: res.req.url,
+            // tryCount: req.tryCount,
+        }));
+        await this.processRetry(res);
+    }
     async processRetry(res) {
         const { retryStatus } = res;
         if (!this.shouldRetry(res)) {
@@ -253,11 +265,14 @@ class Fetcher {
             return;
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = (0, number_util_1._clamp)(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
-        await (0, pDelay_1.pDelay)(retryStatus.retryTimeout);
+        const noise = Math.random() * 500;
+        await (0, pDelay_1.pDelay)(retryStatus.retryTimeout + noise);
     }
     /**
      * Default is yes,
      * unless there's reason not to (e.g method is POST).
+     *
+     * statusCode of 0 (or absense of it) will BE retried.
      */
     shouldRetry(res) {
         const { retryPost, retry4xx, retry5xx } = res.req;
@@ -304,7 +319,7 @@ class Fetcher {
         if (!this.cfg.logWithSearchParams) {
             shortUrl = shortUrl.split('?')[0];
         }
-        if (!this.cfg.logWithPrefixUrl && baseUrl && shortUrl.startsWith(baseUrl)) {
+        if (!this.cfg.logWithBaseUrl && baseUrl && shortUrl.startsWith(baseUrl)) {
             shortUrl = shortUrl.slice(baseUrl.length);
         }
         return shortUrl;
@@ -331,7 +346,7 @@ class Fetcher {
             logRequestBody: debug,
             logResponse: debug,
             logResponseBody: debug,
-            logWithPrefixUrl: true,
+            logWithBaseUrl: (0, env_1.isServerSide)(),
             logWithSearchParams: true,
             retry: { ...defRetryOptions },
             init: {

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

@@ -43,10 +43,19 @@ export interface FetcherCfg {
     logResponse?: boolean;
     logResponseBody?: boolean;
     /**
-     * Default to true.
-     * Set to false to exclude `prefixUrl` from logs (both success and error)
+     * Controls if `baseUrl` should be included in logs (both success and error).
+     *
+     * Defaults to `true` on ServerSide and `false` on ClientSide.
+     *
+     * Reasoning.
+     *
+     * ClientSide often uses one main "backend host".
+     * Not including baseUrl improves Sentry error grouping.
+     *
+     * ServerSide often uses one Fetcher instance per 3rd-party API.
+     * Not including baseUrl can introduce confusion of "which API is it?".
      */
-    logWithPrefixUrl?: boolean;
+    logWithBaseUrl?: boolean;
     /**
      * Default to true.
      * Set to false to strip searchParams from url when logging (both success and error)
@@ -138,6 +147,7 @@ export interface FetcherSuccessResponse<BODY = unknown> {
     req: FetcherRequest;
     statusFamily?: HttpStatusFamily;
     retryStatus: FetcherRetryStatus;
+    signature: string;
 }
 export interface FetcherErrorResponse<BODY = unknown> {
     ok: false;
@@ -147,6 +157,7 @@ export interface FetcherErrorResponse<BODY = unknown> {
     req: FetcherRequest;
     statusFamily?: HttpStatusFamily;
     retryStatus: FetcherRetryStatus;
+    signature: string;
 }
 export type FetcherResponse<BODY = unknown> = FetcherSuccessResponse<BODY> | FetcherErrorResponse<BODY>;
 export type FetcherMode = 'json' | 'text' | 'void' | 'arrayBuffer' | 'blob';

package/dist/index.d.ts

@@ -72,6 +72,7 @@ export * from './datetime/localDate';
 export * from './datetime/localTime';
 export * from './datetime/dateInterval';
 export * from './datetime/timeInterval';
+export * from './env';
 export * from './http/http.model';
 export * from './http/fetcher';
 export * from './http/fetcher.model';

package/dist/index.js

@@ -76,6 +76,7 @@ tslib_1.__exportStar(require("./datetime/localDate"), exports);
 tslib_1.__exportStar(require("./datetime/localTime"), exports);
 tslib_1.__exportStar(require("./datetime/dateInterval"), exports);
 tslib_1.__exportStar(require("./datetime/timeInterval"), exports);
+tslib_1.__exportStar(require("./env"), exports);
 tslib_1.__exportStar(require("./http/http.model"), exports);
 tslib_1.__exportStar(require("./http/fetcher"), exports);
 tslib_1.__exportStar(require("./http/fetcher.model"), exports);

package/dist/string/stringifyAny.js

@@ -81,6 +81,8 @@ function _stringifyAny(obj, opt = {}) {
         }
         if ((0, error_util_1._isErrorObject)(obj)) {
             if ((0, error_util_1._isHttpErrorObject)(obj)) {
+                // Only include (statusCode) if it's non-zero
+                // No: print (0), as it removes ambiguity
                 // `replace` here works ONCE, exactly as we need it
                 s = s.replace('HttpError', `HttpError(${obj.data.httpStatusCode})`);
             }

package/dist/vendor/is.d.ts

@@ -5,9 +5,9 @@
 /// <reference lib="dom" />
 import { Class, ObservableLike, Primitive, TypedArray } from '../typeFest';
 declare const objectTypeNames: readonly ["Function", "Generator", "AsyncGenerator", "GeneratorFunction", "AsyncGeneratorFunction", "AsyncFunction", "Observable", "Array", "Buffer", "Object", "RegExp", "Date", "Error", "Map", "Set", "WeakMap", "WeakSet", "ArrayBuffer", "SharedArrayBuffer", "DataView", "Promise", "URL", "FormData", "URLSearchParams", "HTMLElement", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array"];
-type ObjectTypeName = typeof objectTypeNames[number];
+type ObjectTypeName = (typeof objectTypeNames)[number];
 declare const primitiveTypeNames: readonly ["null", "undefined", "string", "number", "bigint", "boolean", "symbol"];
-type PrimitiveTypeName = typeof primitiveTypeNames[number];
+type PrimitiveTypeName = (typeof primitiveTypeNames)[number];
 export type TypeName = ObjectTypeName | PrimitiveTypeName;
 export declare function is(value: unknown): TypeName;
 export declare namespace is {

package/dist-esm/env.js

@@ -0,0 +1,18 @@
+/**
+ * Use it to detect SSR/Node.js environment.
+ *
+ * Will return `true` in Node.js.
+ * Will return `false` in the Browser.
+ */
+export function isServerSide() {
+    return typeof window === 'undefined';
+}
+/**
+ * Use it to detect Browser (not SSR/Node) environment.
+ *
+ * Will return `true` in the Browser.
+ * Will return `false` in Node.js.
+ */
+export function isClientSide() {
+    return typeof window !== 'undefined';
+}

package/dist-esm/http/fetcher.js

@@ -1,5 +1,6 @@
 /// <reference lib="dom"/>
 import { __asyncValues } from "tslib";
+import { isServerSide } from '../env';
 import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util';
 import { HttpError } from '../error/http.error';
 import { _clamp } from '../number/number.util';
@@ -10,7 +11,7 @@ import { _since } from '../time/time.util';
 import { HTTP_METHODS } from './http.model';
 const defRetryOptions = {
     count: 2,
-    timeout: 500,
+    timeout: 1000,
     timeoutMax: 30000,
     timeoutMultiplier: 2,
 };
@@ -82,10 +83,10 @@ export class Fetcher {
      */
     async rawFetch(url, rawOpt = {}) {
         var _a, e_1, _b, _c, _d, e_2, _e, _f;
-        var _g, _h, _j;
+        var _g;
         const { logger } = this.cfg;
         const req = this.normalizeOptions(url, rawOpt);
-        const { timeoutSeconds, mode, init: { method }, } = req;
+        const { timeoutSeconds, init: { method }, } = req;
         // setup timeout
         let timeout;
         if (timeoutSeconds) {
@@ -96,25 +97,29 @@ export class Fetcher {
             }, timeoutSeconds * 1000);
         }
         try {
-            for (var _k = true, _l = __asyncValues(this.cfg.hooks.beforeRequest || []), _m; _m = await _l.next(), _a = _m.done, !_a;) {
-                _c = _m.value;
-                _k = false;
+            for (var _h = true, _j = __asyncValues(this.cfg.hooks.beforeRequest || []), _k; _k = await _j.next(), _a = _k.done, !_a;) {
+                _c = _k.value;
+                _h = false;
                 try {
                     const hook = _c;
                     await hook(req);
                 }
                 finally {
-                    _k = true;
+                    _h = true;
                 }
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (!_k && !_a && (_b = _l.return)) await _b.call(_l);
+                if (!_h && !_a && (_b = _j.return)) await _b.call(_j);
             }
             finally { if (e_1) throw e_1.error; }
         }
+        const isFullUrl = req.url.includes('://');
+        const fullUrl = isFullUrl ? new URL(req.url) : undefined;
+        const shortUrl = fullUrl ? this.getShortUrl(fullUrl) : req.url;
+        const signature = [method, shortUrl].join(' ');
         const res = {
             req,
             retryStatus: {
@@ -122,10 +127,8 @@ export class Fetcher {
                 retryStopped: false,
                 retryTimeout: req.retry.timeout,
             },
+            signature,
         };
-        const fullUrl = new URL(req.url);
-        const shortUrl = this.getShortUrl(fullUrl);
-        const signature = [method, shortUrl].join(' ');
         /* eslint-disable no-await-in-loop */
         while (!res.retryStatus.retryStopped) {
             const started = Date.now();
@@ -149,114 +152,124 @@ export class Fetcher {
             }
             res.statusFamily = this.getStatusFamily(res);
             if ((_g = res.fetchResponse) === null || _g === void 0 ? void 0 : _g.ok) {
-                if (mode === 'json') {
-                    if (res.fetchResponse.body) {
-                        const text = await res.fetchResponse.text();
-                        if (text) {
-                            try {
-                                res.body = text;
-                                res.body = JSON.parse(text, req.jsonReviver);
-                            }
-                            catch (err) {
-                                const { message } = _anyToError(err);
-                                res.err = new HttpError([signature, message].join('\n'), {
-                                    httpStatusCode: 0,
-                                    url: req.url,
-                                });
-                                res.ok = false;
-                            }
-                        }
-                        else {
-                            // Body had a '' (empty string)
-                            res.body = {};
-                        }
-                    }
-                    else {
-                        // if no body: set responseBody as {}
-                        // do not throw a "cannot parse null as Json" error
-                        res.body = {};
-                    }
-                }
-                else if (mode === 'text') {
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
-                }
-                else if (mode === 'arrayBuffer') {
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {};
-                }
-                else if (mode === 'blob') {
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {};
-                }
-                clearTimeout(timeout);
-                res.retryStatus.retryStopped = true;
-                // res.err can happen on JSON.parse error
-                if (!res.err && this.cfg.logResponse) {
-                    const { retryAttempt } = res.retryStatus;
-                    logger.log([
-                        ' <<',
-                        res.fetchResponse.status,
-                        signature,
-                        retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
-                        _since(started),
-                    ]
-                        .filter(Boolean)
-                        .join(' '));
-                    if (this.cfg.logResponseBody) {
-                        logger.log(res.body);
-                    }
-                }
+                await this.onOkResponse(res, started, timeout);
             }
             else {
                 // !res.ok
-                clearTimeout(timeout);
-                let errObj;
-                if (res.fetchResponse) {
-                    const body = _jsonParseIfPossible(await res.fetchResponse.text());
-                    errObj = _anyToErrorObject(body);
-                }
-                else if (res.err) {
-                    errObj = _errorToErrorObject(res.err);
-                }
-                else {
-                    errObj = {};
-                }
-                const originalMessage = errObj.message;
-                errObj.message = [
-                    [(_h = res.fetchResponse) === null || _h === void 0 ? void 0 : _h.status, signature].filter(Boolean).join(' '),
-                    originalMessage,
-                ]
-                    .filter(Boolean)
-                    .join('\n');
-                res.err = new HttpError(errObj.message, _filterNullishValues(Object.assign(Object.assign({}, errObj.data), { originalMessage, httpStatusCode: ((_j = res.fetchResponse) === null || _j === void 0 ? void 0 : _j.status) || 0, 
-                    // These properties are provided to be used in e.g custom Sentry error grouping
-                    // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
-                    // Enabled, cause `data` is not printed by default when error is HttpError
-                    // method: req.method,
-                    url: req.url })));
-                await this.processRetry(res);
+                await this.onNotOkResponse(res, timeout);
             }
         }
         try {
-            for (var _o = true, _p = __asyncValues(this.cfg.hooks.afterResponse || []), _q; _q = await _p.next(), _d = _q.done, !_d;) {
-                _f = _q.value;
-                _o = false;
+            for (var _l = true, _m = __asyncValues(this.cfg.hooks.afterResponse || []), _o; _o = await _m.next(), _d = _o.done, !_d;) {
+                _f = _o.value;
+                _l = false;
                 try {
                     const hook = _f;
                     await hook(res);
                 }
                 finally {
-                    _o = true;
+                    _l = true;
                 }
             }
         }
         catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
-                if (!_o && !_d && (_e = _p.return)) await _e.call(_p);
+                if (!_l && !_d && (_e = _m.return)) await _e.call(_m);
             }
             finally { if (e_2) throw e_2.error; }
         }
         return res;
     }
+    async onOkResponse(res, started, timeout) {
+        const { req } = res;
+        const { mode } = res.req;
+        if (mode === 'json') {
+            if (res.fetchResponse.body) {
+                const text = await res.fetchResponse.text();
+                if (text) {
+                    try {
+                        res.body = text;
+                        res.body = JSON.parse(text, req.jsonReviver);
+                    }
+                    catch (err) {
+                        const { message } = _anyToError(err);
+                        res.err = new HttpError([res.signature, message].join('\n'), {
+                            httpStatusCode: 0,
+                            url: req.url,
+                        });
+                        res.ok = false;
+                    }
+                }
+                else {
+                    // Body had a '' (empty string)
+                    res.body = {};
+                }
+            }
+            else {
+                // if no body: set responseBody as {}
+                // do not throw a "cannot parse null as Json" error
+                res.body = {};
+            }
+        }
+        else if (mode === 'text') {
+            res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
+        }
+        else if (mode === 'arrayBuffer') {
+            res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {};
+        }
+        else if (mode === 'blob') {
+            res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {};
+        }
+        clearTimeout(timeout);
+        res.retryStatus.retryStopped = true;
+        // res.err can happen on JSON.parse error
+        if (!res.err && this.cfg.logResponse) {
+            const { retryAttempt } = res.retryStatus;
+            const { logger } = this.cfg;
+            logger.log([
+                ' <<',
+                res.fetchResponse.status,
+                res.signature,
+                retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
+                _since(started),
+            ]
+                .filter(Boolean)
+                .join(' '));
+            if (this.cfg.logResponseBody) {
+                logger.log(res.body);
+            }
+        }
+    }
+    async onNotOkResponse(res, timeout) {
+        var _a, _b;
+        clearTimeout(timeout);
+        let errObj;
+        if (res.fetchResponse) {
+            const body = _jsonParseIfPossible(await res.fetchResponse.text());
+            errObj = _anyToErrorObject(body);
+        }
+        else if (res.err) {
+            errObj = _errorToErrorObject(res.err);
+        }
+        else {
+            errObj = {};
+        }
+        const originalMessage = errObj.message;
+        errObj.message = [
+            [(_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status, res.signature].filter(Boolean).join(' '),
+            originalMessage,
+        ]
+            .filter(Boolean)
+            .join('\n');
+        res.err = new HttpError(errObj.message, _filterNullishValues(Object.assign(Object.assign({}, errObj.data), { originalMessage, httpStatusCode: ((_b = res.fetchResponse) === null || _b === void 0 ? void 0 : _b.status) || 0, 
+            // These properties are provided to be used in e.g custom Sentry error grouping
+            // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
+            // Enabled, cause `data` is not printed by default when error is HttpError
+            // method: req.method,
+            url: res.req.url })));
+        await this.processRetry(res);
+    }
     async processRetry(res) {
         var _a, e_3, _b, _c;
         const { retryStatus } = res;
@@ -291,11 +304,14 @@ export class Fetcher {
             return;
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
-        await pDelay(retryStatus.retryTimeout);
+        const noise = Math.random() * 500;
+        await pDelay(retryStatus.retryTimeout + noise);
     }
     /**
      * Default is yes,
      * unless there's reason not to (e.g method is POST).
+     *
+     * statusCode of 0 (or absense of it) will BE retried.
      */
     shouldRetry(res) {
         var _a;
@@ -344,7 +360,7 @@ export class Fetcher {
         if (!this.cfg.logWithSearchParams) {
             shortUrl = shortUrl.split('?')[0];
         }
-        if (!this.cfg.logWithPrefixUrl && baseUrl && shortUrl.startsWith(baseUrl)) {
+        if (!this.cfg.logWithBaseUrl && baseUrl && shortUrl.startsWith(baseUrl)) {
             shortUrl = shortUrl.slice(baseUrl.length);
         }
         return shortUrl;
@@ -372,7 +388,7 @@ export class Fetcher {
             logRequestBody: debug,
             logResponse: debug,
             logResponseBody: debug,
-            logWithPrefixUrl: true,
+            logWithBaseUrl: isServerSide(),
             logWithSearchParams: true,
             retry: Object.assign({}, defRetryOptions),
             init: {

package/dist-esm/index.js

@@ -72,6 +72,7 @@ export * from './datetime/localDate';
 export * from './datetime/localTime';
 export * from './datetime/dateInterval';
 export * from './datetime/timeInterval';
+export * from './env';
 export * from './http/http.model';
 export * from './http/fetcher';
 export * from './http/fetcher.model';

package/dist-esm/string/stringifyAny.js

@@ -77,6 +77,8 @@ export function _stringifyAny(obj, opt = {}) {
         }
         if (_isErrorObject(obj)) {
             if (_isHttpErrorObject(obj)) {
+                // Only include (statusCode) if it's non-zero
+                // No: print (0), as it removes ambiguity
                 // `replace` here works ONCE, exactly as we need it
                 s = s.replace('HttpError', `HttpError(${obj.data.httpStatusCode})`);
             }

package/package.json

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

package/src/env.ts

@@ -0,0 +1,19 @@
+/**
+ * Use it to detect SSR/Node.js environment.
+ *
+ * Will return `true` in Node.js.
+ * Will return `false` in the Browser.
+ */
+export function isServerSide(): boolean {
+  return typeof window === 'undefined'
+}
+
+/**
+ * Use it to detect Browser (not SSR/Node) environment.
+ *
+ * Will return `true` in the Browser.
+ * Will return `false` in Node.js.
+ */
+export function isClientSide(): boolean {
+  return typeof window !== 'undefined'
+}

package/src/http/fetcher.model.ts

@@ -49,10 +49,19 @@ export interface FetcherCfg {
   logResponseBody?: boolean
 
   /**
-   * Default to true.
-   * Set to false to exclude `prefixUrl` from logs (both success and error)
+   * Controls if `baseUrl` should be included in logs (both success and error).
+   *
+   * Defaults to `true` on ServerSide and `false` on ClientSide.
+   *
+   * Reasoning.
+   *
+   * ClientSide often uses one main "backend host".
+   * Not including baseUrl improves Sentry error grouping.
+   *
+   * ServerSide often uses one Fetcher instance per 3rd-party API.
+   * Not including baseUrl can introduce confusion of "which API is it?".
    */
-  logWithPrefixUrl?: boolean
+  logWithBaseUrl?: boolean
 
   /**
    * Default to true.
@@ -165,6 +174,7 @@ export interface FetcherSuccessResponse<BODY = unknown> {
   req: FetcherRequest
   statusFamily?: HttpStatusFamily
   retryStatus: FetcherRetryStatus
+  signature: string
 }
 
 export interface FetcherErrorResponse<BODY = unknown> {
@@ -175,6 +185,7 @@ export interface FetcherErrorResponse<BODY = unknown> {
   req: FetcherRequest
   statusFamily?: HttpStatusFamily
   retryStatus: FetcherRetryStatus
+  signature: string
 }
 
 export type FetcherResponse<BODY = unknown> =

package/src/http/fetcher.ts

@@ -1,5 +1,6 @@
 /// <reference lib="dom"/>
 
+import { isServerSide } from '../env'
 import { ErrorObject } from '../error/error.model'
 import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util'
 import { HttpError } from '../error/http.error'
@@ -30,7 +31,7 @@ import type { HttpStatusFamily } from './http.model'
 
 const defRetryOptions: FetcherRetryOptions = {
   count: 2,
-  timeout: 500,
+  timeout: 1000,
   timeoutMax: 30_000,
   timeoutMultiplier: 2,
 }
@@ -151,7 +152,6 @@ export class Fetcher {
     const req = this.normalizeOptions(url, rawOpt)
     const {
       timeoutSeconds,
-      mode,
       init: { method },
     } = req
 
@@ -169,6 +169,11 @@ export class Fetcher {
       await hook(req)
     }
 
+    const isFullUrl = req.url.includes('://')
+    const fullUrl = isFullUrl ? new URL(req.url) : undefined
+    const shortUrl = fullUrl ? this.getShortUrl(fullUrl) : req.url
+    const signature = [method, shortUrl].join(' ')
+
     const res = {
       req,
       retryStatus: {
@@ -176,12 +181,9 @@ export class Fetcher {
         retryStopped: false,
         retryTimeout: req.retry.timeout,
       },
+      signature,
     } as FetcherResponse<any>
 
-    const fullUrl = new URL(req.url)
-    const shortUrl = this.getShortUrl(fullUrl)
-    const signature = [method, shortUrl].join(' ')
-
     /* eslint-disable no-await-in-loop */
     while (!res.retryStatus.retryStopped) {
       const started = Date.now()
@@ -209,109 +211,129 @@ export class Fetcher {
       res.statusFamily = this.getStatusFamily(res)
 
       if (res.fetchResponse?.ok) {
-        if (mode === 'json') {
-          if (res.fetchResponse.body) {
-            const text = await res.fetchResponse.text()
-
-            if (text) {
-              try {
-                res.body = text
-                res.body = JSON.parse(text, req.jsonReviver)
-              } catch (err) {
-                const { message } = _anyToError(err)
-                res.err = new HttpError([signature, message].join('\n'), {
-                  httpStatusCode: 0,
-                  url: req.url,
-                })
-                res.ok = false
-              }
-            } else {
-              // Body had a '' (empty string)
-              res.body = {}
-            }
-          } else {
-            // if no body: set responseBody as {}
-            // do not throw a "cannot parse null as Json" error
-            res.body = {}
-          }
-        } else if (mode === 'text') {
-          res.body = res.fetchResponse.body ? await res.fetchResponse.text() : ''
-        } else if (mode === 'arrayBuffer') {
-          res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {}
-        } else if (mode === 'blob') {
-          res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {}
-        }
-
-        clearTimeout(timeout)
-        res.retryStatus.retryStopped = true
-
-        // res.err can happen on JSON.parse error
-        if (!res.err && this.cfg.logResponse) {
-          const { retryAttempt } = res.retryStatus
-          logger.log(
-            [
-              ' <<',
-              res.fetchResponse.status,
-              signature,
-              retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
-              _since(started),
-            ]
-              .filter(Boolean)
-              .join(' '),
-          )
-
-          if (this.cfg.logResponseBody) {
-            logger.log(res.body)
-          }
-        }
+        await this.onOkResponse(
+          res as FetcherResponse<T> & { fetchResponse: Response },
+          started,
+          timeout,
+        )
       } else {
         // !res.ok
-        clearTimeout(timeout)
+        await this.onNotOkResponse(res, timeout)
+      }
+    }
+
+    for await (const hook of this.cfg.hooks.afterResponse || []) {
+      await hook(res)
+    }
 
-        let errObj: ErrorObject
+    return res
+  }
 
-        if (res.fetchResponse) {
-          const body = _jsonParseIfPossible(await res.fetchResponse.text())
-          errObj = _anyToErrorObject(body)
-        } else if (res.err) {
-          errObj = _errorToErrorObject(res.err)
+  private async onOkResponse(
+    res: FetcherResponse<any> & { fetchResponse: Response },
+    started: number,
+    timeout?: number,
+  ): Promise<void> {
+    const { req } = res
+    const { mode } = res.req
+
+    if (mode === 'json') {
+      if (res.fetchResponse.body) {
+        const text = await res.fetchResponse.text()
+
+        if (text) {
+          try {
+            res.body = text
+            res.body = JSON.parse(text, req.jsonReviver)
+          } catch (err) {
+            const { message } = _anyToError(err)
+            res.err = new HttpError([res.signature, message].join('\n'), {
+              httpStatusCode: 0,
+              url: req.url,
+            })
+            res.ok = false
+          }
         } else {
-          errObj = {} as ErrorObject
+          // Body had a '' (empty string)
+          res.body = {}
         }
+      } else {
+        // if no body: set responseBody as {}
+        // do not throw a "cannot parse null as Json" error
+        res.body = {}
+      }
+    } else if (mode === 'text') {
+      res.body = res.fetchResponse.body ? await res.fetchResponse.text() : ''
+    } else if (mode === 'arrayBuffer') {
+      res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {}
+    } else if (mode === 'blob') {
+      res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {}
+    }
 
-        const originalMessage = errObj.message
-        errObj.message = [
-          [res.fetchResponse?.status, signature].filter(Boolean).join(' '),
-          originalMessage,
+    clearTimeout(timeout)
+    res.retryStatus.retryStopped = true
+
+    // res.err can happen on JSON.parse error
+    if (!res.err && this.cfg.logResponse) {
+      const { retryAttempt } = res.retryStatus
+      const { logger } = this.cfg
+      logger.log(
+        [
+          ' <<',
+          res.fetchResponse.status,
+          res.signature,
+          retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
+          _since(started),
         ]
           .filter(Boolean)
-          .join('\n')
-
-        res.err = new HttpError(
-          errObj.message,
-
-          _filterNullishValues({
-            ...errObj.data,
-            originalMessage,
-            httpStatusCode: res.fetchResponse?.status || 0,
-            // These properties are provided to be used in e.g custom Sentry error grouping
-            // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
-            // Enabled, cause `data` is not printed by default when error is HttpError
-            // method: req.method,
-            url: req.url,
-            // tryCount: req.tryCount,
-          }),
-        )
+          .join(' '),
+      )
 
-        await this.processRetry(res)
+      if (this.cfg.logResponseBody) {
+        logger.log(res.body)
       }
     }
+  }
 
-    for await (const hook of this.cfg.hooks.afterResponse || []) {
-      await hook(res)
+  private async onNotOkResponse(res: FetcherResponse, timeout?: number): Promise<void> {
+    clearTimeout(timeout)
+
+    let errObj: ErrorObject
+
+    if (res.fetchResponse) {
+      const body = _jsonParseIfPossible(await res.fetchResponse.text())
+      errObj = _anyToErrorObject(body)
+    } else if (res.err) {
+      errObj = _errorToErrorObject(res.err)
+    } else {
+      errObj = {} as ErrorObject
     }
 
-    return res
+    const originalMessage = errObj.message
+    errObj.message = [
+      [res.fetchResponse?.status, res.signature].filter(Boolean).join(' '),
+      originalMessage,
+    ]
+      .filter(Boolean)
+      .join('\n')
+
+    res.err = new HttpError(
+      errObj.message,
+
+      _filterNullishValues({
+        ...errObj.data,
+        originalMessage,
+        httpStatusCode: res.fetchResponse?.status || 0,
+        // These properties are provided to be used in e.g custom Sentry error grouping
+        // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
+        // Enabled, cause `data` is not printed by default when error is HttpError
+        // method: req.method,
+        url: res.req.url,
+        // tryCount: req.tryCount,
+      }),
+    )
+
+    await this.processRetry(res)
   }
 
   private async processRetry(res: FetcherResponse): Promise<void> {
@@ -336,12 +358,15 @@ export class Fetcher {
     retryStatus.retryAttempt++
     retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax)
 
-    await pDelay(retryStatus.retryTimeout)
+    const noise = Math.random() * 500
+    await pDelay(retryStatus.retryTimeout + noise)
   }
 
   /**
    * Default is yes,
    * unless there's reason not to (e.g method is POST).
+   *
+   * statusCode of 0 (or absense of it) will BE retried.
    */
   private shouldRetry(res: FetcherResponse): boolean {
     const { retryPost, retry4xx, retry5xx } = res.req
@@ -385,7 +410,7 @@ export class Fetcher {
       shortUrl = shortUrl.split('?')[0]!
     }
 
-    if (!this.cfg.logWithPrefixUrl && baseUrl && shortUrl.startsWith(baseUrl)) {
+    if (!this.cfg.logWithBaseUrl && baseUrl && shortUrl.startsWith(baseUrl)) {
       shortUrl = shortUrl.slice(baseUrl.length)
     }
 
@@ -416,7 +441,7 @@ export class Fetcher {
         logRequestBody: debug,
         logResponse: debug,
         logResponseBody: debug,
-        logWithPrefixUrl: true,
+        logWithBaseUrl: isServerSide(),
         logWithSearchParams: true,
         retry: { ...defRetryOptions },
         init: {

package/src/index.ts

@@ -72,6 +72,7 @@ export * from './datetime/localDate'
 export * from './datetime/localTime'
 export * from './datetime/dateInterval'
 export * from './datetime/timeInterval'
+export * from './env'
 export * from './http/http.model'
 export * from './http/fetcher'
 export * from './http/fetcher.model'

package/src/string/stringifyAny.ts

@@ -125,6 +125,8 @@ export function _stringifyAny(obj: any, opt: StringifyAnyOptions = {}): string {
 
     if (_isErrorObject(obj)) {
       if (_isHttpErrorObject(obj)) {
+        // Only include (statusCode) if it's non-zero
+        // No: print (0), as it removes ambiguity
         // `replace` here works ONCE, exactly as we need it
         s = s.replace('HttpError', `HttpError(${obj.data.httpStatusCode})`)
       }

package/src/vendor/is.ts

@@ -25,7 +25,7 @@ const typedArrayTypeNames = [
   'BigUint64Array',
 ] as const
 
-type TypedArrayTypeName = typeof typedArrayTypeNames[number]
+type TypedArrayTypeName = (typeof typedArrayTypeNames)[number]
 
 function isTypedArrayName(name: unknown): name is TypedArrayTypeName {
   return typedArrayTypeNames.includes(name as TypedArrayTypeName)
@@ -60,7 +60,7 @@ const objectTypeNames = [
   ...typedArrayTypeNames,
 ] as const
 
-type ObjectTypeName = typeof objectTypeNames[number]
+type ObjectTypeName = (typeof objectTypeNames)[number]
 
 function isObjectTypeName(name: unknown): name is ObjectTypeName {
   return objectTypeNames.includes(name as ObjectTypeName)
@@ -76,7 +76,7 @@ const primitiveTypeNames = [
   'symbol',
 ] as const
 
-type PrimitiveTypeName = typeof primitiveTypeNames[number]
+type PrimitiveTypeName = (typeof primitiveTypeNames)[number]
 
 function isPrimitiveTypeName(name: unknown): name is PrimitiveTypeName {
   return primitiveTypeNames.includes(name as PrimitiveTypeName)