npm - @naturalcycles/js-lib - Versions diffs - 14.119.1 → 14.121.0 - Mend

@naturalcycles/js-lib 14.119.1 → 14.121.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/http/fetcher.d.ts +39 -11
package/dist/http/fetcher.js +66 -69
package/dist/http/http.model.d.ts +2 -1
package/dist/http/http.model.js +2 -0
package/dist-esm/http/fetcher.js +113 -50
package/dist-esm/http/http.model.js +1 -1
package/package.json +1 -1
package/src/http/fetcher.ts +120 -77
package/src/http/http.model.ts +3 -1

package/dist/http/fetcher.d.ts CHANGED Viewed

@@ -2,11 +2,17 @@
 import { CommonLogger } from '../log/commonLogger';
 import type { Promisable } from '../typeFest';
 import type { HttpMethod, HttpStatusFamily } from './http.model';
-export interface FetcherNormalizedCfg extends FetcherCfg, FetcherRequest {
+export interface FetcherNormalizedCfg extends Required<FetcherCfg>, FetcherRequest {
     logger: CommonLogger;
     searchParams: Record<string, any>;
 }
+export type FetcherBeforeRequestHook = (req: FetcherRequest) => Promisable<void>;
+export type FetcherAfterResponseHook = (res: FetcherResponse) => Promisable<void>;
+export type FetcherBeforeRetryHook = (res: FetcherResponse) => Promisable<void>;
 export interface FetcherCfg {
+    /**
+     * Should **not** contain trailing slash.
+     */
     baseUrl?: string;
     /**
      * Default rule is that you **are allowed** to mutate req, res, res.retryStatus
@@ -17,22 +23,28 @@ export interface FetcherCfg {
         /**
          * Allows to mutate req.
          */
-        beforeRequest?(req: FetcherRequest): Promisable<void>;
+        beforeRequest?: FetcherBeforeRequestHook[];
         /**
          * Allows to mutate res.
          * If you set `res.err` - it will be thrown.
          */
-        beforeResponse?(res: FetcherResponse): Promisable<void>;
+        afterResponse?: FetcherAfterResponseHook[];
         /**
          * Allows to mutate res.retryStatus to override retry behavior.
          */
-        beforeRetry?(res: FetcherResponse): Promisable<void>;
+        beforeRetry?: FetcherBeforeRetryHook[];
     };
+    /**
+     * If true - enables all possible logging.
+     */
     debug?: boolean;
     logRequest?: boolean;
     logRequestBody?: boolean;
     logResponse?: boolean;
     logResponseBody?: boolean;
+    /**
+     * Defaults to `console`.
+     */
     logger?: CommonLogger;
 }
 export interface FetcherRetryStatus {
@@ -68,7 +80,7 @@ export interface FetcherOptions {
     timeoutSeconds?: number;
     json?: any;
     text?: string;
-    init?: Partial<RequestInitNormalized>;
+    credentials?: RequestCredentials;
     headers?: Record<string, any>;
     mode?: FetcherMode;
     searchParams?: Record<string, any>;
@@ -120,14 +132,30 @@ export type FetcherMode = 'json' | 'text';
  */
 export declare class Fetcher {
     private constructor();
+    /**
+     * Add BeforeRequest hook at the end of the hooks list.
+     */
+    onBeforeRequest(hook: FetcherBeforeRequestHook): this;
+    onAfterResponse(hook: FetcherAfterResponseHook): this;
+    onBeforeRetry(hook: FetcherBeforeRetryHook): this;
     cfg: FetcherNormalizedCfg;
     static create(cfg?: FetcherCfg & FetcherOptions): Fetcher;
-    getJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T>;
-    postJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T>;
-    putJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T>;
-    patchJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T>;
-    deleteJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T>;
-    getText(url: string, opt?: FetcherOptions): Promise<string>;
+    get: (url: string, opt?: FetcherOptions) => Promise<void>;
+    post: (url: string, opt?: FetcherOptions) => Promise<void>;
+    put: (url: string, opt?: FetcherOptions) => Promise<void>;
+    patch: (url: string, opt?: FetcherOptions) => Promise<void>;
+    delete: (url: string, opt?: FetcherOptions) => Promise<void>;
+    head: (url: string, opt?: FetcherOptions) => Promise<void>;
+    getText: (url: string, opt?: FetcherOptions) => Promise<string>;
+    postText: (url: string, opt?: FetcherOptions) => Promise<string>;
+    putText: (url: string, opt?: FetcherOptions) => Promise<string>;
+    patchText: (url: string, opt?: FetcherOptions) => Promise<string>;
+    deleteText: (url: string, opt?: FetcherOptions) => Promise<string>;
+    getJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
+    postJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
+    putJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
+    patchJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
+    deleteJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
     fetch<T = unknown>(url: string, opt?: FetcherOptions): Promise<T>;
     rawFetch<T = unknown>(url: string, rawOpt?: FetcherOptions): Promise<FetcherResponse<T>>;
     private processRetry;

package/dist/http/fetcher.js CHANGED Viewed

@@ -9,6 +9,7 @@ const object_util_1 = require("../object/object.util");
 const pDelay_1 = require("../promise/pDelay");
 const json_util_1 = require("../string/json.util");
 const time_util_1 = require("../time/time.util");
+const http_model_1 = require("./http.model");
 const defRetryOptions = {
     count: 2,
     timeout: 500,
@@ -24,50 +25,53 @@ const defRetryOptions = {
 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, {
-            ...opt,
-            mode: 'json',
+        // Dynamically create all helper methods
+        http_model_1.HTTP_METHODS.forEach(method => {
+            // mode=void
+            this[method] = async (url, opt) => {
+                return await this.fetch(url, {
+                    ...opt,
+                    method,
+                });
+            };
+            this[`${method}Text`] = async (url, opt) => {
+                return await this.fetch(url, {
+                    ...opt,
+                    method,
+                    mode: 'text',
+                });
+            };
+            this[`${method}Json`] = async (url, opt) => {
+                return await this.fetch(url, {
+                    ...opt,
+                    method,
+                    mode: 'json',
+                });
+            };
         });
     }
-    async postJson(url, opt) {
-        return await this.fetch(url, {
-            ...opt,
-            method: 'post',
-            mode: 'json',
-        });
+    /**
+     * Add BeforeRequest hook at the end of the hooks list.
+     */
+    onBeforeRequest(hook) {
+        ;
+        (this.cfg.hooks.beforeRequest ||= []).push(hook);
+        return this;
     }
-    async putJson(url, opt) {
-        return await this.fetch(url, {
-            ...opt,
-            method: 'put',
-            mode: 'json',
-        });
+    onAfterResponse(hook) {
+        ;
+        (this.cfg.hooks.afterResponse ||= []).push(hook);
+        return this;
     }
-    async patchJson(url, opt) {
-        return await this.fetch(url, {
-            ...opt,
-            method: 'patch',
-            mode: 'json',
-        });
+    onBeforeRetry(hook) {
+        ;
+        (this.cfg.hooks.beforeRetry ||= []).push(hook);
+        return this;
     }
-    async deleteJson(url, opt) {
-        return await this.fetch(url, {
-            ...opt,
-            method: 'delete',
-            mode: 'json',
-        });
-    }
-    async getText(url, opt) {
-        return await this.fetch(url, {
-            ...opt,
-            mode: 'text',
-        });
+    static create(cfg = {}) {
+        return new Fetcher(cfg);
     }
+    // headJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
     async fetch(url, opt) {
         const res = await this.rawFetch(url, opt);
         if (res.err) {
@@ -90,7 +94,9 @@ class Fetcher {
                 abortController.abort(`timeout of ${timeoutSeconds} sec`);
             }, timeoutSeconds * 1000);
         }
-        await this.cfg.hooks?.beforeRequest?.(req);
+        for await (const hook of this.cfg.hooks.beforeRequest || []) {
+            await hook(req);
+        }
         const res = {
             req,
             retryStatus: {
@@ -159,29 +165,12 @@ class Fetcher {
                     url: req.url,
                     // tryCount: req.tryCount,
                 }));
-                // 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 this.cfg.hooks?.beforeResponse?.(res);
+        for await (const hook of this.cfg.hooks.afterResponse || []) {
+            await hook(res);
+        }
         return res;
     }
     async processRetry(res) {
@@ -189,7 +178,9 @@ class Fetcher {
         if (!this.shouldRetry(res)) {
             retryStatus.retryStopped = true;
         }
-        await this.cfg.hooks?.beforeRetry?.(res);
+        for await (const hook of this.cfg.hooks.beforeRetry || []) {
+            await hook(res);
+        }
         const { count, timeoutMultiplier, timeoutMax } = res.req.retry;
         if (retryStatus.retryAttempt >= count) {
             retryStatus.retryStopped = true;
@@ -210,9 +201,9 @@ class Fetcher {
         if (method === 'post' && !retryPost)
             return false;
         const { statusFamily } = res;
-        if (statusFamily === '5xx' && !retry5xx)
+        if (statusFamily === 5 && !retry5xx)
             return false;
-        if (statusFamily === '4xx' && !retry4xx)
+        if (statusFamily === 4 && !retry4xx)
             return false;
         return true; // default is true
     }
@@ -221,15 +212,15 @@ class Fetcher {
         if (!status)
             return;
         if (status >= 500)
-            return '5xx';
+            return 5;
         if (status >= 400)
-            return '4xx';
+            return 4;
         if (status >= 300)
-            return '3xx';
+            return 3;
         if (status >= 200)
-            return '2xx';
+            return 2;
         if (status >= 100)
-            return '1xx';
+            return 1;
     }
     /**
      * Returns url without baseUrl and before ?queryString
@@ -245,8 +236,9 @@ class Fetcher {
             console.warn(`Fetcher: baseUrl should not end with /`);
             cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1);
         }
-        const { debug } = cfg;
+        const { debug = false } = cfg;
         const norm = (0, object_util_1._merge)({
+            baseUrl: '',
             url: '',
             searchParams: {},
             timeoutSeconds: 30,
@@ -255,6 +247,7 @@ class Fetcher {
             retry4xx: false,
             retry5xx: true,
             logger: console,
+            debug,
             logRequest: debug,
             logRequestBody: debug,
             logResponse: debug,
@@ -264,6 +257,7 @@ class Fetcher {
                 method: 'get',
                 headers: {},
             },
+            hooks: {},
         }, cfg);
         norm.init.headers = (0, object_util_1._mapKeys)(norm.init.headers, k => k.toLowerCase());
         return norm;
@@ -282,8 +276,11 @@ class Fetcher {
                 ...retry,
                 ...(0, object_util_1._filterUndefinedValues)(opt.retry || {}),
             },
-            init: (0, object_util_1._merge)({ ...this.cfg.init }, opt.init, (0, object_util_1._filterUndefinedValues)({
+            init: (0, object_util_1._merge)({ ...this.cfg.init },
+            // opt.init,
+            (0, object_util_1._filterUndefinedValues)({
                 method: opt.method,
+                credentials: opt.credentials,
                 headers: (0, object_util_1._mapKeys)(opt.headers || {}, k => k.toLowerCase()),
             })),
         };

package/dist/http/http.model.d.ts CHANGED Viewed

@@ -1,2 +1,3 @@
 export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head';
-export type HttpStatusFamily = '5xx' | '4xx' | '3xx' | '2xx' | '1xx';
+export type HttpStatusFamily = 5 | 4 | 3 | 2 | 1;
+export declare const HTTP_METHODS: HttpMethod[];

package/dist/http/http.model.js CHANGED Viewed

@@ -1,2 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_METHODS = void 0;
+exports.HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head'];

package/dist-esm/http/fetcher.js CHANGED Viewed

@@ -1,4 +1,5 @@
 /// <reference lib="dom"/>
+import { __asyncValues } from "tslib";
 import { _anyToErrorObject } from '../error/error.util';
 import { HttpError } from '../error/http.error';
 import { _clamp } from '../number/number.util';
@@ -6,6 +7,7 @@ import { _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit,
 import { pDelay } from '../promise/pDelay';
 import { _jsonParseIfPossible } from '../string/json.util';
 import { _since } from '../time/time.util';
+import { HTTP_METHODS } from './http.model';
 const defRetryOptions = {
     count: 2,
     timeout: 500,
@@ -21,28 +23,45 @@ const defRetryOptions = {
 export class Fetcher {
     constructor(cfg = {}) {
         this.cfg = this.normalizeCfg(cfg);
+        // Dynamically create all helper methods
+        HTTP_METHODS.forEach(method => {
+            // mode=void
+            this[method] = async (url, opt) => {
+                return await this.fetch(url, Object.assign(Object.assign({}, opt), { method }));
+            };
+            this[`${method}Text`] = async (url, opt) => {
+                return await this.fetch(url, Object.assign(Object.assign({}, opt), { method, mode: 'text' }));
+            };
+            this[`${method}Json`] = async (url, opt) => {
+                return await this.fetch(url, Object.assign(Object.assign({}, opt), { method, mode: 'json' }));
+            };
+        });
     }
-    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 putJson(url, opt) {
-        return await this.fetch(url, Object.assign(Object.assign({}, opt), { method: 'put', mode: 'json' }));
+    /**
+     * Add BeforeRequest hook at the end of the hooks list.
+     */
+    onBeforeRequest(hook) {
+        var _a;
+        ;
+        ((_a = this.cfg.hooks).beforeRequest || (_a.beforeRequest = [])).push(hook);
+        return this;
     }
-    async patchJson(url, opt) {
-        return await this.fetch(url, Object.assign(Object.assign({}, opt), { method: 'patch', mode: 'json' }));
+    onAfterResponse(hook) {
+        var _a;
+        ;
+        ((_a = this.cfg.hooks).afterResponse || (_a.afterResponse = [])).push(hook);
+        return this;
     }
-    async deleteJson(url, opt) {
-        return await this.fetch(url, Object.assign(Object.assign({}, opt), { method: 'delete', mode: 'json' }));
+    onBeforeRetry(hook) {
+        var _a;
+        ;
+        ((_a = this.cfg.hooks).beforeRetry || (_a.beforeRetry = [])).push(hook);
+        return this;
     }
-    async getText(url, opt) {
-        return await this.fetch(url, Object.assign(Object.assign({}, opt), { mode: 'text' }));
+    static create(cfg = {}) {
+        return new Fetcher(cfg);
     }
+    // headJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
     async fetch(url, opt) {
         const res = await this.rawFetch(url, opt);
         if (res.err) {
@@ -53,7 +72,7 @@ export class Fetcher {
         return res.body;
     }
     async rawFetch(url, rawOpt = {}) {
-        var _a, _b, _c, _d;
+        var _a, e_1, _b, _c, _d, e_2, _e, _f;
         const { logger } = this.cfg;
         const req = this.normalizeOptions(url, rawOpt);
         const { timeoutSeconds, mode, init: { method }, } = req;
@@ -66,7 +85,26 @@ export class Fetcher {
                 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));
+        try {
+            for (var _g = true, _h = __asyncValues(this.cfg.hooks.beforeRequest || []), _j; _j = await _h.next(), _a = _j.done, !_a;) {
+                _c = _j.value;
+                _g = false;
+                try {
+                    const hook = _c;
+                    await hook(req);
+                }
+                finally {
+                    _g = true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_g && !_a && (_b = _h.return)) await _b.call(_h);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
         const res = {
             req,
             retryStatus: {
@@ -130,38 +168,57 @@ export class Fetcher {
                     // 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));
+        try {
+            for (var _k = true, _l = __asyncValues(this.cfg.hooks.afterResponse || []), _m; _m = await _l.next(), _d = _m.done, !_d;) {
+                _f = _m.value;
+                _k = false;
+                try {
+                    const hook = _f;
+                    await hook(res);
+                }
+                finally {
+                    _k = true;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (!_k && !_d && (_e = _l.return)) await _e.call(_l);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
         return res;
     }
     async processRetry(res) {
-        var _a, _b;
+        var _a, e_3, _b, _c;
         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));
+        try {
+            for (var _d = true, _e = __asyncValues(this.cfg.hooks.beforeRetry || []), _f; _f = await _e.next(), _a = _f.done, !_a;) {
+                _c = _f.value;
+                _d = false;
+                try {
+                    const hook = _c;
+                    await hook(res);
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
         const { count, timeoutMultiplier, timeoutMax } = res.req.retry;
         if (retryStatus.retryAttempt >= count) {
             retryStatus.retryStopped = true;
@@ -182,9 +239,9 @@ export class Fetcher {
         if (method === 'post' && !retryPost)
             return false;
         const { statusFamily } = res;
-        if (statusFamily === '5xx' && !retry5xx)
+        if (statusFamily === 5 && !retry5xx)
             return false;
-        if (statusFamily === '4xx' && !retry4xx)
+        if (statusFamily === 4 && !retry4xx)
             return false;
         return true; // default is true
     }
@@ -194,15 +251,15 @@ export class Fetcher {
         if (!status)
             return;
         if (status >= 500)
-            return '5xx';
+            return 5;
         if (status >= 400)
-            return '4xx';
+            return 4;
         if (status >= 300)
-            return '3xx';
+            return 3;
         if (status >= 200)
-            return '2xx';
+            return 2;
         if (status >= 100)
-            return '1xx';
+            return 1;
     }
     /**
      * Returns url without baseUrl and before ?queryString
@@ -219,8 +276,9 @@ export class Fetcher {
             console.warn(`Fetcher: baseUrl should not end with /`);
             cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1);
         }
-        const { debug } = cfg;
+        const { debug = false } = cfg;
         const norm = _merge({
+            baseUrl: '',
             url: '',
             searchParams: {},
             timeoutSeconds: 30,
@@ -229,6 +287,7 @@ export class Fetcher {
             retry4xx: false,
             retry5xx: true,
             logger: console,
+            debug,
             logRequest: debug,
             logRequestBody: debug,
             logResponse: debug,
@@ -238,6 +297,7 @@ export class Fetcher {
                 method: 'get',
                 headers: {},
             },
+            hooks: {},
         }, cfg);
         norm.init.headers = _mapKeys(norm.init.headers, k => k.toLowerCase());
         return norm;
@@ -249,8 +309,11 @@ export class Fetcher {
             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({
+            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,
+                credentials: opt.credentials,
                 headers: _mapKeys(opt.headers || {}, k => k.toLowerCase()),
             })) });
         // setup url

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

	@@ -1 +1 @@
1	- export {};
1	+ export const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head'];

package/package.json CHANGED Viewed

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

package/src/http/fetcher.ts CHANGED Viewed

@@ -15,14 +15,22 @@ import { pDelay } from '../promise/pDelay'
 import { _jsonParseIfPossible } from '../string/json.util'
 import { _since } from '../time/time.util'
 import type { Promisable } from '../typeFest'
+import { HTTP_METHODS } from './http.model'
 import type { HttpMethod, HttpStatusFamily } from './http.model'
-export interface FetcherNormalizedCfg extends FetcherCfg, FetcherRequest {
+export interface FetcherNormalizedCfg extends Required<FetcherCfg>, FetcherRequest {
   logger: CommonLogger
   searchParams: Record<string, any>
 }
+export type FetcherBeforeRequestHook = (req: FetcherRequest) => Promisable<void>
+export type FetcherAfterResponseHook = (res: FetcherResponse) => Promisable<void>
+export type FetcherBeforeRetryHook = (res: FetcherResponse) => Promisable<void>
 export interface FetcherCfg {
+  /**
+   * Should **not** contain trailing slash.
+   */
   baseUrl?: string
   /**
@@ -34,23 +42,30 @@ export interface FetcherCfg {
     /**
      * Allows to mutate req.
      */
-    beforeRequest?(req: FetcherRequest): Promisable<void>
+    beforeRequest?: FetcherBeforeRequestHook[]
     /**
      * Allows to mutate res.
      * If you set `res.err` - it will be thrown.
      */
-    beforeResponse?(res: FetcherResponse): Promisable<void>
+    afterResponse?: FetcherAfterResponseHook[]
     /**
      * Allows to mutate res.retryStatus to override retry behavior.
      */
-    beforeRetry?(res: FetcherResponse): Promisable<void>
+    beforeRetry?: FetcherBeforeRetryHook[]
   }
+  /**
+   * If true - enables all possible logging.
+   */
   debug?: boolean
   logRequest?: boolean
   logRequestBody?: boolean
   logResponse?: boolean
   logResponseBody?: boolean
+  /**
+   * Defaults to `console`.
+   */
   logger?: CommonLogger
 }
@@ -90,7 +105,13 @@ export interface FetcherOptions {
   timeoutSeconds?: number
   json?: any
   text?: string
-  init?: Partial<RequestInitNormalized>
+  credentials?: RequestCredentials
+  // Removing RequestInit from options to simplify FetcherOptions interface.
+  // Will instead only add hand-picked useful options, such as `credentials`.
+  // init?: Partial<RequestInitNormalized>
   headers?: Record<string, any>
   mode?: FetcherMode // default to undefined (void response)
@@ -159,56 +180,88 @@ const defRetryOptions: FetcherRetryOptions = {
 export class Fetcher {
   private constructor(cfg: FetcherCfg & FetcherOptions = {}) {
     this.cfg = this.normalizeCfg(cfg)
-  }
-  public cfg: FetcherNormalizedCfg
+    // Dynamically create all helper methods
+    HTTP_METHODS.forEach(method => {
+      // mode=void
+      this[method] = async (url: string, opt?: FetcherOptions): Promise<void> => {
+        return await this.fetch<void>(url, {
+          ...opt,
+          method,
+        })
+      }
-  static create(cfg: FetcherCfg & FetcherOptions = {}): Fetcher {
-    return new Fetcher(cfg)
-  }
+      // mode=text
+      ;(this as any)[`${method}Text`] = async (
+        url: string,
+        opt?: FetcherOptions,
+      ): Promise<string> => {
+        return await this.fetch<string>(url, {
+          ...opt,
+          method,
+          mode: 'text',
+        })
+      }
-  async getJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T> {
-    return await this.fetch<T>(url, {
-      ...opt,
-      mode: 'json',
-    })
-  }
-  async postJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T> {
-    return await this.fetch<T>(url, {
-      ...opt,
-      method: 'post',
-      mode: 'json',
+      // mode=json
+      ;(this as any)[`${method}Json`] = async <T = unknown>(
+        url: string,
+        opt?: FetcherOptions,
+      ): Promise<T> => {
+        return await this.fetch<T>(url, {
+          ...opt,
+          method,
+          mode: 'json',
+        })
+      }
     })
   }
-  async putJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T> {
-    return await this.fetch<T>(url, {
-      ...opt,
-      method: 'put',
-      mode: 'json',
-    })
+  /**
+   * Add BeforeRequest hook at the end of the hooks list.
+   */
+  onBeforeRequest(hook: FetcherBeforeRequestHook): this {
+    ;(this.cfg.hooks.beforeRequest ||= []).push(hook)
+    return this
   }
-  async patchJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T> {
-    return await this.fetch<T>(url, {
-      ...opt,
-      method: 'patch',
-      mode: 'json',
-    })
+  onAfterResponse(hook: FetcherAfterResponseHook): this {
+    ;(this.cfg.hooks.afterResponse ||= []).push(hook)
+    return this
   }
-  async deleteJson<T = unknown>(url: string, opt?: FetcherOptions): Promise<T> {
-    return await this.fetch<T>(url, {
-      ...opt,
-      method: 'delete',
-      mode: 'json',
-    })
+  onBeforeRetry(hook: FetcherBeforeRetryHook): this {
+    ;(this.cfg.hooks.beforeRetry ||= []).push(hook)
+    return this
   }
-  async getText(url: string, opt?: FetcherOptions): Promise<string> {
-    return await this.fetch<string>(url, {
-      ...opt,
-      mode: 'text',
-    })
+  public cfg: FetcherNormalizedCfg
+  static create(cfg: FetcherCfg & FetcherOptions = {}): Fetcher {
+    return new Fetcher(cfg)
   }
+  // These methods are generated dynamically in the constructor
+  get!: (url: string, opt?: FetcherOptions) => Promise<void>
+  post!: (url: string, opt?: FetcherOptions) => Promise<void>
+  put!: (url: string, opt?: FetcherOptions) => Promise<void>
+  patch!: (url: string, opt?: FetcherOptions) => Promise<void>
+  delete!: (url: string, opt?: FetcherOptions) => Promise<void>
+  head!: (url: string, opt?: FetcherOptions) => Promise<void>
+  getText!: (url: string, opt?: FetcherOptions) => Promise<string>
+  postText!: (url: string, opt?: FetcherOptions) => Promise<string>
+  putText!: (url: string, opt?: FetcherOptions) => Promise<string>
+  patchText!: (url: string, opt?: FetcherOptions) => Promise<string>
+  deleteText!: (url: string, opt?: FetcherOptions) => Promise<string>
+  getJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  postJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  putJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  patchJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  deleteJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  // headJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
   async fetch<T = unknown>(url: string, opt?: FetcherOptions): Promise<T> {
     const res = await this.rawFetch<T>(url, opt)
     if (res.err) {
@@ -241,7 +294,9 @@ export class Fetcher {
       }, timeoutSeconds * 1000) as any as number
     }
-    await this.cfg.hooks?.beforeRequest?.(req)
+    for await (const hook of this.cfg.hooks.beforeRequest || []) {
+      await hook(req)
+    }
     const res: FetcherResponse<any> = {
       req,
@@ -330,31 +385,13 @@ export class Fetcher {
           }),
         )
-        // 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 this.cfg.hooks?.beforeResponse?.(res)
+    for await (const hook of this.cfg.hooks.afterResponse || []) {
+      await hook(res)
+    }
     return res
   }
@@ -366,7 +403,9 @@ export class Fetcher {
       retryStatus.retryStopped = true
     }
-    await this.cfg.hooks?.beforeRetry?.(res)
+    for await (const hook of this.cfg.hooks.beforeRetry || []) {
+      await hook(res)
+    }
     const { count, timeoutMultiplier, timeoutMax } = res.req.retry
@@ -391,19 +430,19 @@ export class Fetcher {
     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
+    if (statusFamily === 5 && !retry5xx) return false
+    if (statusFamily === 4 && !retry4xx) return false
     return true // default is true
   }
   private getStatusFamily(res: FetcherResponse): HttpStatusFamily | undefined {
     const status = res.fetchResponse?.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'
+    if (status >= 500) return 5
+    if (status >= 400) return 4
+    if (status >= 300) return 3
+    if (status >= 200) return 2
+    if (status >= 100) return 1
   }
   /**
@@ -421,10 +460,11 @@ export class Fetcher {
       console.warn(`Fetcher: baseUrl should not end with /`)
       cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1)
     }
-    const { debug } = cfg
+    const { debug = false } = cfg
     const norm: FetcherNormalizedCfg = _merge(
       {
+        baseUrl: '',
         url: '',
         searchParams: {},
         timeoutSeconds: 30,
@@ -433,6 +473,7 @@ export class Fetcher {
         retry4xx: false,
         retry5xx: true,
         logger: console,
+        debug,
         logRequest: debug,
         logRequestBody: debug,
         logResponse: debug,
@@ -442,6 +483,7 @@ export class Fetcher {
           method: 'get',
           headers: {},
         },
+        hooks: {},
       },
       cfg,
     )
@@ -469,11 +511,12 @@ export class Fetcher {
       },
       init: _merge(
         { ...this.cfg.init },
-        opt.init,
+        // opt.init,
         _filterUndefinedValues({
           method: opt.method,
+          credentials: opt.credentials,
           headers: _mapKeys(opt.headers || {}, k => k.toLowerCase()),
-        }),
+        } as RequestInit),
       ),
     }

package/src/http/http.model.ts CHANGED Viewed

@@ -1,3 +1,5 @@
 export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head'
-export type HttpStatusFamily = '5xx' | '4xx' | '3xx' | '2xx' | '1xx'
+export type HttpStatusFamily = 5 | 4 | 3 | 2 | 1
+export const HTTP_METHODS: HttpMethod[] = ['get', 'post', 'put', 'patch', 'delete', 'head']