@naturalcycles/js-lib 14.117.1 → 14.119.0

package/dist-esm/http/fetcher.js

@@ -0,0 +1,277 @@
+/// <reference lib="dom"/>
+import { _anyToErrorObject } from '../error/error.util';
+import { HttpError } from '../error/http.error';
+import { _clamp } from '../number/number.util';
+import { _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, } from '../object/object.util';
+import { pDelay } from '../promise/pDelay';
+import { _jsonParseIfPossible } from '../string/json.util';
+import { _since } from '../time/time.util';
+const defRetryOptions = {
+    count: 2,
+    timeout: 500,
+    timeoutMax: 30000,
+    timeoutMultiplier: 2,
+};
+/**
+ * Experimental wrapper around Fetch.
+ * Works in both Browser and Node, using `globalThis.fetch`.
+ *
+ * @experimental
+ */
+export class Fetcher {
+    constructor(cfg = {}) {
+        this.cfg = this.normalizeCfg(cfg);
+    }
+    static create(cfg = {}) {
+        return new Fetcher(cfg);
+    }
+    async getJson(url, opt = {}) {
+        return await this.fetch(url, Object.assign(Object.assign({}, opt), { mode: 'json' }));
+    }
+    async postJson(url, opt = {}) {
+        return await this.fetch(url, Object.assign(Object.assign({}, opt), { method: 'post', mode: 'json' }));
+    }
+    async getText(url, opt = {}) {
+        return await this.fetch(url, Object.assign(Object.assign({}, opt), { mode: 'text' }));
+    }
+    async postText(url, opt = {}) {
+        return await this.fetch(url, Object.assign(Object.assign({}, opt), { method: 'post', mode: 'text' }));
+    }
+    async fetch(url, opt = {}) {
+        const res = await this.rawFetch(url, opt);
+        if (res.err) {
+            if (res.req.throwHttpErrors)
+                throw res.err;
+            return res;
+        }
+        return res.body;
+    }
+    async rawFetch(url, rawOpt = {}) {
+        var _a, _b, _c, _d;
+        const { logger } = this.cfg;
+        const req = this.normalizeOptions(url, rawOpt);
+        const { timeoutSeconds, mode, init: { method }, } = req;
+        // setup timeout
+        let timeout;
+        if (timeoutSeconds) {
+            const abortController = new AbortController();
+            req.init.signal = abortController.signal;
+            timeout = setTimeout(() => {
+                abortController.abort(`timeout of ${timeoutSeconds} sec`);
+            }, timeoutSeconds * 1000);
+        }
+        await ((_b = (_a = this.cfg.hooks) === null || _a === void 0 ? void 0 : _a.beforeRequest) === null || _b === void 0 ? void 0 : _b.call(_a, req));
+        const res = {
+            req,
+            retryStatus: {
+                retryAttempt: 0,
+                retryStopped: false,
+                retryTimeout: req.retry.timeout,
+            },
+        };
+        const shortUrl = this.getShortUrl(req.url);
+        const signature = [method.toUpperCase(), shortUrl].join(' ');
+        /* eslint-disable no-await-in-loop */
+        while (!res.retryStatus.retryStopped) {
+            const started = Date.now();
+            if (this.cfg.logRequest) {
+                const { retryAttempt } = res.retryStatus;
+                logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count}`]
+                    .filter(Boolean)
+                    .join(' '));
+                if (this.cfg.logRequestBody && req.init.body) {
+                    logger.log(req.init.body); // todo: check if we can _inspect it
+                }
+            }
+            res.fetchResponse = await globalThis.fetch(req.url, req.init);
+            res.statusFamily = this.getStatusFamily(res);
+            if (res.fetchResponse.ok) {
+                if (mode === 'json') {
+                    // if no body: set responseBody as {}
+                    // do not throw a "cannot parse null as Json" error
+                    res.body = res.fetchResponse.body ? await res.fetchResponse.json() : {};
+                }
+                else if (mode === 'text') {
+                    res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
+                }
+                clearTimeout(timeout);
+                res.retryStatus.retryStopped = true;
+                if (this.cfg.logResponse) {
+                    const { retryAttempt } = res.retryStatus;
+                    logger.log([
+                        ' <<',
+                        res.fetchResponse.status,
+                        signature,
+                        retryAttempt && `try#${retryAttempt + 1}/${req.retry.count}`,
+                        _since(started),
+                    ]
+                        .filter(Boolean)
+                        .join(' '));
+                    if (this.cfg.logResponseBody) {
+                        logger.log(res.body);
+                    }
+                }
+            }
+            else {
+                clearTimeout(timeout);
+                const body = _jsonParseIfPossible(await res.fetchResponse.text());
+                const errObj = _anyToErrorObject(body);
+                const originalMessage = errObj.message;
+                errObj.message = [[res.fetchResponse.status, signature].join(' '), originalMessage].join('\n');
+                res.err = new HttpError(errObj.message, _filterNullishValues(Object.assign(Object.assign({}, errObj.data), { originalMessage, httpStatusCode: res.fetchResponse.status, 
+                    // 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 })));
+                // We don't log errors when they are also thrown,
+                // otherwise it gets logged twice: here, and upstream
+                // if (this.cfg.logResponse) {
+                //   const { retryAttempt } = res.retryStatus
+                //   logger.error(
+                //     [
+                //       [
+                //         ' <<',
+                //         res.fetchResponse.status,
+                //         signature,
+                //         retryAttempt && `try#${retryAttempt + 1}/${req.retry.count}`,
+                //         _since(started),
+                //       ]
+                //         .filter(Boolean)
+                //         .join(' '),
+                //       _stringifyAny(body),
+                //     ].join('\n'),
+                //   )
+                // }
+                await this.processRetry(res);
+            }
+        }
+        await ((_d = (_c = this.cfg.hooks) === null || _c === void 0 ? void 0 : _c.beforeResponse) === null || _d === void 0 ? void 0 : _d.call(_c, res));
+        return res;
+    }
+    async processRetry(res) {
+        var _a, _b;
+        const { retryStatus } = res;
+        if (!this.shouldRetry(res)) {
+            retryStatus.retryStopped = true;
+        }
+        await ((_b = (_a = this.cfg.hooks) === null || _a === void 0 ? void 0 : _a.beforeRetry) === null || _b === void 0 ? void 0 : _b.call(_a, res));
+        const { count, timeoutMultiplier, timeoutMax } = res.req.retry;
+        if (retryStatus.retryAttempt >= count) {
+            retryStatus.retryStopped = true;
+        }
+        if (retryStatus.retryStopped)
+            return;
+        retryStatus.retryAttempt++;
+        retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
+        await pDelay(retryStatus.retryTimeout);
+    }
+    /**
+     * Default is yes,
+     * unless there's reason not to (e.g method is POST).
+     */
+    shouldRetry(res) {
+        const { retryPost, retry4xx, retry5xx } = res.req;
+        const { method } = res.req.init;
+        if (method === 'post' && !retryPost)
+            return false;
+        const { statusFamily } = res;
+        if (statusFamily === '5xx' && !retry5xx)
+            return false;
+        if (statusFamily === '4xx' && !retry4xx)
+            return false;
+        return true; // default is true
+    }
+    getStatusFamily(res) {
+        var _a;
+        const status = (_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status;
+        if (!status)
+            return;
+        if (status >= 500)
+            return '5xx';
+        if (status >= 400)
+            return '4xx';
+        if (status >= 300)
+            return '3xx';
+        if (status >= 200)
+            return '2xx';
+        if (status >= 100)
+            return '1xx';
+    }
+    /**
+     * Returns url without baseUrl and before ?queryString
+     */
+    getShortUrl(url) {
+        const { baseUrl } = this.cfg;
+        if (!baseUrl)
+            return url;
+        return url.split('?')[0].slice(baseUrl.length);
+    }
+    normalizeCfg(cfg) {
+        var _a;
+        if ((_a = cfg.baseUrl) === null || _a === void 0 ? void 0 : _a.endsWith('/')) {
+            console.warn(`Fetcher: baseUrl should not end with /`);
+            cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1);
+        }
+        const { debug } = cfg;
+        const norm = _merge({
+            url: '',
+            searchParams: {},
+            timeoutSeconds: 30,
+            throwHttpErrors: true,
+            retryPost: false,
+            retry4xx: false,
+            retry5xx: true,
+            logger: console,
+            logRequest: debug,
+            logRequestBody: debug,
+            logResponse: debug,
+            logResponseBody: debug,
+            retry: Object.assign({}, defRetryOptions),
+            init: {
+                method: 'get',
+                headers: {},
+            },
+        }, cfg);
+        norm.init.headers = _mapKeys(norm.init.headers, k => k.toLowerCase());
+        return norm;
+    }
+    normalizeOptions(url, opt) {
+        const { baseUrl, timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry } = this.cfg;
+        const req = Object.assign(Object.assign({ url,
+            timeoutSeconds,
+            throwHttpErrors,
+            retryPost,
+            retry4xx,
+            retry5xx }, _omit(opt, ['method', 'headers'])), { retry: Object.assign(Object.assign({}, retry), _filterUndefinedValues(opt.retry || {})), init: _merge(Object.assign({}, this.cfg.init), opt.init, _filterUndefinedValues({
+                method: opt.method,
+                headers: _mapKeys(opt.headers || {}, k => k.toLowerCase()),
+            })) });
+        // setup url
+        if (baseUrl) {
+            if (url.startsWith('/')) {
+                console.warn(`Fetcher: url should not start with / when baseUrl is specified`);
+                url = url.slice(1);
+            }
+            req.url = `${baseUrl}/${url}`;
+        }
+        const searchParams = Object.assign(Object.assign({}, this.cfg.searchParams), opt.searchParams);
+        if (Object.keys(searchParams).length) {
+            const qs = new URLSearchParams(searchParams).toString();
+            req.url += req.url.includes('?') ? '&' : '?' + qs;
+        }
+        // setup request body
+        if (opt.json !== undefined) {
+            req.init.body = JSON.stringify(opt.json);
+            req.init.headers['content-type'] = 'application/json';
+        }
+        else if (opt.text !== undefined) {
+            req.init.body = opt.text;
+            req.init.headers['content-type'] = 'text/plain';
+        }
+        return req;
+    }
+}
+export function getFetcher(cfg = {}) {
+    return Fetcher.create(cfg);
+}

package/dist-esm/http/http.model.js

@@ -0,0 +1 @@
+export {};

package/dist-esm/index.js

@@ -74,4 +74,6 @@ export * from './datetime/localDate';
 export * from './datetime/localTime';
 export * from './datetime/dateInterval';
 export * from './datetime/timeInterval';
+export * from './http/http.model';
+export * from './http/fetcher';
 export { is };

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

@@ -168,6 +168,8 @@ export function _filterEmptyValues(obj, mutate = false) {
  * are applied from left to right. Subsequent sources overwrite property
  * assignments of previous sources.
  *
+ * Works as "recursive Object.assign".
+ *
  * **Note:** This method mutates `object`.
  *
  * @category Object
@@ -191,18 +193,20 @@ export function _filterEmptyValues(obj, mutate = false) {
  */
 export function _merge(target, ...sources) {
     sources.forEach(source => {
-        if (_isObject(source)) {
-            Object.keys(source).forEach(key => {
-                if (_isObject(source[key])) {
-                    if (!target[key])
-                        Object.assign(target, { [key]: {} });
-                    _merge(target[key], source[key]);
-                }
-                else {
-                    Object.assign(target, { [key]: source[key] });
-                }
-            });
-        }
+        if (!_isObject(source))
+            return;
+        Object.keys(source).forEach(key => {
+            var _a;
+            if (_isObject(source[key])) {
+                ;
+                (_a = target)[key] || (_a[key] = {});
+                _merge(target[key], source[key]);
+            }
+            else {
+                ;
+                target[key] = source[key];
+            }
+        });
     });
     return target;
 }

package/dist-esm/string/stringifyAny.js

@@ -53,7 +53,8 @@ export function _stringifyAny(obj, opt = {}) {
             // This is to fix the rare error (happened with Got) where `err.message` was changed,
             // but err.stack had "old" err.message
             // This should "fix" that
-            s = [s, ...obj.stack.split('\n').slice(1)].join('\n');
+            const sLines = s.split('\n').length;
+            s = [s, ...obj.stack.split('\n').slice(sLines)].join('\n');
         }
         if (_isErrorObject(obj)) {
             if (_isHttpErrorObject(obj)) {

package/package.json

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

package/src/error/app.error.ts

@@ -27,14 +27,15 @@ export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
       enumerable: false,
     })
 
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor)
-    } else {
-      Object.defineProperty(this, 'stack', {
-        value: new Error().stack, // eslint-disable-line unicorn/error-message
-        writable: true,
-        configurable: true,
-      })
-    }
+    // todo: check if it's needed at all!
+    // if (Error.captureStackTrace) {
+    //   Error.captureStackTrace(this, this.constructor)
+    // } else {
+    //   Object.defineProperty(this, 'stack', {
+    //     value: new Error().stack, // eslint-disable-line unicorn/error-message
+    //     writable: true,
+    //     configurable: true,
+    //   })
+    // }
   }
 }