@naturalcycles/js-lib 14.145.0 → 14.147.0

package/dist/http/fetcher.d.ts

@@ -14,36 +14,36 @@ export declare class Fetcher {
     onBeforeRetry(hook: FetcherBeforeRetryHook): this;
     cfg: FetcherNormalizedCfg;
     static create(cfg?: FetcherCfg & FetcherOptions): Fetcher;
-    get: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
-    post: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
-    put: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
-    patch: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
-    delete: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
-    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>;
-    getVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
-    postVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
-    putVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
-    patchVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
-    deleteVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
-    headVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
+    get: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    post: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    put: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    patch: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    delete: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    getText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    postText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    putText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    patchText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    deleteText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    getVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    postVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    putVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    patchVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    deleteVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    headVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
     /**
      * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>
      *
      * More on streams and Node interop:
      * https://css-tricks.com/web-streams-everywhere-and-fetch-for-node-js/
      */
-    getReadableStream(url: string, opt?: FetcherOptions): Promise<ReadableStream<Uint8Array>>;
-    fetch<T = unknown>(url: string, opt?: FetcherOptions): Promise<T>;
+    getReadableStream(url: string, opt?: FetcherOptions<ReadableStream<Uint8Array>>): Promise<ReadableStream<Uint8Array>>;
+    fetch<T = unknown>(opt: FetcherOptions<T>): Promise<T>;
     /**
      * Returns FetcherResponse.
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
      */
-    doFetch<T = unknown>(url: string, rawOpt?: FetcherOptions): Promise<FetcherResponse<T>>;
+    doFetch<T = unknown>(opt: FetcherOptions<T>): Promise<FetcherResponse<T>>;
     private onOkResponse;
     /**
      * This method exists to be able to easily mock it.

package/dist/http/fetcher.js

@@ -31,7 +31,8 @@ class Fetcher {
         http_model_1.HTTP_METHODS.forEach(method => {
             const m = method.toLowerCase();
             this[`${m}Void`] = async (url, opt) => {
-                return await this.fetch(url, {
+                return await this.fetch({
+                    url,
                     method,
                     mode: 'void',
                     ...opt,
@@ -41,14 +42,16 @@ class Fetcher {
                 return // mode=text
                 ;
             this[`${m}Text`] = async (url, opt) => {
-                return await this.fetch(url, {
+                return await this.fetch({
+                    url,
                     method,
                     mode: 'text',
                     ...opt,
                 });
             };
             this[m] = async (url, opt) => {
-                return await this.fetch(url, {
+                return await this.fetch({
+                    url,
                     method,
                     mode: 'json',
                     ...opt,
@@ -85,13 +88,14 @@ class Fetcher {
      * https://css-tricks.com/web-streams-everywhere-and-fetch-for-node-js/
      */
     async getReadableStream(url, opt) {
-        return await this.fetch(url, {
+        return await this.fetch({
+            url,
             mode: 'readableStream',
             ...opt,
         });
     }
-    async fetch(url, opt) {
-        const res = await this.doFetch(url, opt);
+    async fetch(opt) {
+        const res = await this.doFetch(opt);
         if (res.err) {
             if (res.req.throwHttpErrors)
                 throw res.err;
@@ -104,9 +108,9 @@ class Fetcher {
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
      */
-    async doFetch(url, rawOpt = {}) {
+    async doFetch(opt) {
+        const req = this.normalizeOptions(opt);
         const { logger } = this.cfg;
-        const req = this.normalizeOptions(url, rawOpt);
         const { timeoutSeconds, init: { method }, } = req;
         // setup timeout
         let timeout;
@@ -117,12 +121,12 @@ class Fetcher {
                 abortController.abort(`timeout of ${timeoutSeconds} sec`);
             }, timeoutSeconds * 1000);
         }
-        for await (const hook of this.cfg.hooks.beforeRequest || []) {
+        for (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 isFullUrl = req.fullUrl.includes('://');
+        const fullUrl = isFullUrl ? new URL(req.fullUrl) : undefined;
+        const shortUrl = fullUrl ? this.getShortUrl(fullUrl) : req.fullUrl;
         const signature = [method, shortUrl].join(' ');
         const res = {
             req,
@@ -134,7 +138,7 @@ class Fetcher {
             signature,
         };
         while (!res.retryStatus.retryStopped) {
-            const started = Date.now();
+            req.started = Date.now();
             if (this.cfg.logRequest) {
                 const { retryAttempt } = res.retryStatus;
                 logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
@@ -145,7 +149,7 @@ class Fetcher {
                 }
             }
             try {
-                res.fetchResponse = await this.callNativeFetch(req.url, req.init);
+                res.fetchResponse = await this.callNativeFetch(req.fullUrl, req.init);
                 res.ok = res.fetchResponse.ok;
             }
             catch (err) {
@@ -157,19 +161,25 @@ class Fetcher {
             }
             res.statusFamily = this.getStatusFamily(res);
             if (res.fetchResponse?.ok) {
-                await this.onOkResponse(res, started, timeout);
+                await this.onOkResponse(res, timeout);
             }
             else {
                 // !res.ok
-                await this.onNotOkResponse(res, started, timeout);
+                await this.onNotOkResponse(res, timeout);
             }
         }
-        for await (const hook of this.cfg.hooks.afterResponse || []) {
+        for (const hook of this.cfg.hooks.afterResponse || []) {
             await hook(res);
         }
+        if (req.paginate && res.ok) {
+            const proceeed = await req.paginate(res, opt);
+            if (proceeed) {
+                return await this.doFetch(opt);
+            }
+        }
         return res;
     }
-    async onOkResponse(res, started, timeout) {
+    async onOkResponse(res, timeout) {
         const { req } = res;
         const { mode } = res.req;
         if (mode === 'json') {
@@ -192,7 +202,7 @@ class Fetcher {
                         // } satisfies HttpRequestErrorData)
                         res.err = (0, error_util_1._anyToError)(err);
                         res.ok = false;
-                        return await this.onNotOkResponse(res, started, timeout);
+                        return await this.onNotOkResponse(res, timeout);
                     }
                 }
                 else {
@@ -220,7 +230,7 @@ class Fetcher {
             if (res.body === null) {
                 res.err = new Error(`fetchResponse.body is null`);
                 res.ok = false;
-                return await this.onNotOkResponse(res, started, timeout);
+                return await this.onNotOkResponse(res, timeout);
             }
         }
         clearTimeout(timeout);
@@ -234,7 +244,7 @@ class Fetcher {
                 res.fetchResponse.status,
                 res.signature,
                 retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
-                (0, time_util_1._since)(started),
+                (0, time_util_1._since)(res.req.started),
             ]
                 .filter(Boolean)
                 .join(' '));
@@ -249,7 +259,7 @@ class Fetcher {
     async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
-    async onNotOkResponse(res, started, timeout) {
+    async onNotOkResponse(res, timeout) {
         clearTimeout(timeout);
         let cause;
         if (res.err) {
@@ -271,11 +281,11 @@ class Fetcher {
             // Enabled, cause `data` is not printed by default when error is HttpError
             // method: req.method,
             // tryCount: req.tryCount,
-            requestUrl: res.req.url,
+            requestUrl: res.req.fullUrl,
             requestBaseUrl: this.cfg.baseUrl || null,
             requestMethod: res.req.init.method,
             requestSignature: res.signature,
-            requestDuration: Date.now() - started,
+            requestDuration: Date.now() - res.req.started,
         }), cause);
         await this.processRetry(res);
     }
@@ -284,7 +294,7 @@ class Fetcher {
         if (!this.shouldRetry(res)) {
             retryStatus.retryStopped = true;
         }
-        for await (const hook of this.cfg.hooks.beforeRetry || []) {
+        for (const hook of this.cfg.hooks.beforeRetry || []) {
             await hook(res);
         }
         const { count, timeoutMultiplier, timeoutMax } = res.req.retry;
@@ -293,6 +303,22 @@ class Fetcher {
         }
         if (retryStatus.retryStopped)
             return;
+        // Here we know that more retries will be attempted
+        // We don't log "last error", because it will be thrown and logged by consumer,
+        // but we should log all previous errors, otherwise they are lost.
+        // Here is the right place where we know it's not the "last error"
+        if (res.err) {
+            const { retryAttempt } = retryStatus;
+            this.cfg.logger.error([
+                ' <<',
+                res.fetchResponse?.status || 0,
+                res.signature,
+                `try#${retryAttempt + 1}/${count + 1}`,
+                (0, time_util_1._since)(res.req.started),
+            ]
+                .filter(Boolean)
+                .join(' '), res.err.cause || res.err);
+        }
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = (0, number_util_1._clamp)(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
         const noise = Math.random() * 500;
@@ -362,7 +388,7 @@ class Fetcher {
         const { debug = false } = cfg;
         const norm = (0, object_util_1._merge)({
             baseUrl: '',
-            url: '',
+            inputUrl: '',
             mode: 'void',
             searchParams: {},
             timeoutSeconds: 30,
@@ -390,11 +416,11 @@ class Fetcher {
         norm.init.headers = (0, object_util_1._mapKeys)(norm.init.headers, k => k.toLowerCase());
         return norm;
     }
-    normalizeOptions(url, opt) {
+    normalizeOptions(opt) {
         const { timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry, mode, jsonReviver, } = this.cfg;
         const req = {
+            started: Date.now(),
             mode,
-            url,
             timeoutSeconds,
             throwHttpErrors,
             retryPost,
@@ -402,6 +428,8 @@ class Fetcher {
             retry5xx,
             jsonReviver,
             ...(0, object_util_1._omit)(opt, ['method', 'headers', 'credentials']),
+            inputUrl: opt.url || '',
+            fullUrl: opt.url || '',
             retry: {
                 ...retry,
                 ...(0, object_util_1._filterUndefinedValues)(opt.retry || {}),
@@ -418,11 +446,11 @@ class Fetcher {
         // setup url
         const baseUrl = opt.baseUrl || this.cfg.baseUrl;
         if (baseUrl) {
-            if (url.startsWith('/')) {
+            if (req.fullUrl.startsWith('/')) {
                 console.warn(`Fetcher: url should not start with / when baseUrl is specified`);
-                url = url.slice(1);
+                req.fullUrl = req.fullUrl.slice(1);
             }
-            req.url = `${baseUrl}/${url}`;
+            req.fullUrl = `${baseUrl}/${req.inputUrl}`;
         }
         const searchParams = (0, object_util_1._filterUndefinedValues)({
             ...this.cfg.searchParams,
@@ -430,7 +458,7 @@ class Fetcher {
         });
         if (Object.keys(searchParams).length) {
             const qs = new URLSearchParams(searchParams).toString();
-            req.url += req.url.includes('?') ? '&' : '?' + qs;
+            req.fullUrl += req.fullUrl.includes('?') ? '&' : '?' + qs;
         }
         // setup request body
         if (opt.json !== undefined) {

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

@@ -1,14 +1,14 @@
 import type { CommonLogger } from '../log/commonLogger';
 import type { Promisable } from '../typeFest';
-import type { Reviver } from '../types';
+import type { Reviver, UnixTimestampMillisNumber } from '../types';
 import type { HttpMethod, HttpStatusFamily } from './http.model';
-export interface FetcherNormalizedCfg extends Required<FetcherCfg>, FetcherRequest {
+export interface FetcherNormalizedCfg extends Required<FetcherCfg>, Omit<FetcherRequest, 'started' | 'fullUrl'> {
     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 type FetcherBeforeRequestHook = <BODY = unknown>(req: FetcherRequest<BODY>) => Promisable<void>;
+export type FetcherAfterResponseHook = <BODY = unknown>(res: FetcherResponse<BODY>) => Promisable<void>;
+export type FetcherBeforeRetryHook = <BODY = unknown>(res: FetcherResponse<BODY>) => Promisable<void>;
 export interface FetcherCfg {
     /**
      * Should **not** contain trailing slash.
@@ -77,8 +77,16 @@ export interface FetcherRetryOptions {
     timeoutMax: number;
     timeoutMultiplier: number;
 }
-export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl'> {
-    url: string;
+export interface FetcherRequest<BODY = unknown> extends Omit<FetcherOptions<BODY>, 'method' | 'headers' | 'baseUrl' | 'url'> {
+    /**
+     * inputUrl is only the part that was passed in the request,
+     * without baseUrl or searchParams.
+     */
+    inputUrl: string;
+    /**
+     * fullUrl includes baseUrl and searchParams.
+     */
+    fullUrl: string;
     init: RequestInitNormalized;
     mode: FetcherMode;
     throwHttpErrors: boolean;
@@ -87,9 +95,15 @@ export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers
     retryPost: boolean;
     retry4xx: boolean;
     retry5xx: boolean;
+    started: UnixTimestampMillisNumber;
 }
-export interface FetcherOptions {
+export interface FetcherOptions<BODY = unknown> {
     method?: HttpMethod;
+    /**
+     * If defined - this `url` will override the original given `url`.
+     * baseUrl (and searchParams) will still modify it.
+     */
+    url?: string;
     baseUrl?: string;
     throwHttpErrors?: boolean;
     /**
@@ -134,6 +148,21 @@ export interface FetcherOptions {
      */
     retry5xx?: boolean;
     jsonReviver?: Reviver;
+    /**
+     * Allows to walk over multiple pages of results.
+     * Paginate take a function.
+     * Function has access to FetcherResponse and FetcherOptions
+     * and has to make a decision to continue pagination or not.
+     *
+     * Return false to stop pagination.
+     * Return true to continue pagination.
+     * Feel free to mutate/modify opt (FetcherOptions), for example:
+     *
+     * opt.searchParams!['page']++
+     *
+     * @experimental
+     */
+    paginate?: (res: FetcherSuccessResponse<BODY>, opt: FetcherOptions<BODY>) => Promisable<boolean>;
 }
 export type RequestInitNormalized = Omit<RequestInit, 'method' | 'headers'> & {
     method: HttpMethod;

package/dist/promise/pMap.js

@@ -51,7 +51,7 @@ async function pMap(iterable, mapper, opt = {}) {
     // Special cases that are able to preserve async stack traces
     if (concurrency === 1) {
         // Special case for concurrency == 1
-        for await (const item of items) {
+        for (const item of items) {
             try {
                 const r = await mapper(item, currentIndex++);
                 if (r === __1.END)

package/dist-esm/http/fetcher.js

@@ -1,5 +1,4 @@
 /// <reference lib="dom"/>
-import { __asyncValues } from "tslib";
 import { isServerSide } from '../env';
 import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util';
 import { HttpRequestError } from '../error/httpRequestError';
@@ -29,16 +28,19 @@ export class Fetcher {
         HTTP_METHODS.forEach(method => {
             const m = method.toLowerCase();
             this[`${m}Void`] = async (url, opt) => {
-                return await this.fetch(url, Object.assign({ method, mode: 'void' }, opt));
+                return await this.fetch(Object.assign({ url,
+                    method, mode: 'void' }, opt));
             };
             if (method === 'HEAD')
                 return // mode=text
                 ;
             this[`${m}Text`] = async (url, opt) => {
-                return await this.fetch(url, Object.assign({ method, mode: 'text' }, opt));
+                return await this.fetch(Object.assign({ url,
+                    method, mode: 'text' }, opt));
             };
             this[m] = async (url, opt) => {
-                return await this.fetch(url, Object.assign({ method, mode: 'json' }, opt));
+                return await this.fetch(Object.assign({ url,
+                    method, mode: 'json' }, opt));
             };
         });
     }
@@ -74,10 +76,10 @@ export class Fetcher {
      * https://css-tricks.com/web-streams-everywhere-and-fetch-for-node-js/
      */
     async getReadableStream(url, opt) {
-        return await this.fetch(url, Object.assign({ mode: 'readableStream' }, opt));
+        return await this.fetch(Object.assign({ url, mode: 'readableStream' }, opt));
     }
-    async fetch(url, opt) {
-        const res = await this.doFetch(url, opt);
+    async fetch(opt) {
+        const res = await this.doFetch(opt);
         if (res.err) {
             if (res.req.throwHttpErrors)
                 throw res.err;
@@ -90,11 +92,10 @@ export class Fetcher {
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
      */
-    async doFetch(url, rawOpt = {}) {
-        var _a, e_1, _b, _c, _d, e_2, _e, _f;
-        var _g;
+    async doFetch(opt) {
+        var _a;
+        const req = this.normalizeOptions(opt);
         const { logger } = this.cfg;
-        const req = this.normalizeOptions(url, rawOpt);
         const { timeoutSeconds, init: { method }, } = req;
         // setup timeout
         let timeout;
@@ -105,29 +106,12 @@ export class Fetcher {
                 abortController.abort(`timeout of ${timeoutSeconds} sec`);
             }, timeoutSeconds * 1000);
         }
-        try {
-            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 {
-                    _h = true;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_h && !_a && (_b = _j.return)) await _b.call(_j);
-            }
-            finally { if (e_1) throw e_1.error; }
+        for (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 isFullUrl = req.fullUrl.includes('://');
+        const fullUrl = isFullUrl ? new URL(req.fullUrl) : undefined;
+        const shortUrl = fullUrl ? this.getShortUrl(fullUrl) : req.fullUrl;
         const signature = [method, shortUrl].join(' ');
         const res = {
             req,
@@ -139,7 +123,7 @@ export class Fetcher {
             signature,
         };
         while (!res.retryStatus.retryStopped) {
-            const started = Date.now();
+            req.started = Date.now();
             if (this.cfg.logRequest) {
                 const { retryAttempt } = res.retryStatus;
                 logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
@@ -150,7 +134,7 @@ export class Fetcher {
                 }
             }
             try {
-                res.fetchResponse = await this.callNativeFetch(req.url, req.init);
+                res.fetchResponse = await this.callNativeFetch(req.fullUrl, req.init);
                 res.ok = res.fetchResponse.ok;
             }
             catch (err) {
@@ -161,37 +145,26 @@ export class Fetcher {
                 res.fetchResponse = undefined;
             }
             res.statusFamily = this.getStatusFamily(res);
-            if ((_g = res.fetchResponse) === null || _g === void 0 ? void 0 : _g.ok) {
-                await this.onOkResponse(res, started, timeout);
+            if ((_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.ok) {
+                await this.onOkResponse(res, timeout);
             }
             else {
                 // !res.ok
-                await this.onNotOkResponse(res, started, timeout);
+                await this.onNotOkResponse(res, timeout);
             }
         }
-        try {
-            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 {
-                    _l = true;
-                }
-            }
+        for (const hook of this.cfg.hooks.afterResponse || []) {
+            await hook(res);
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (!_l && !_d && (_e = _m.return)) await _e.call(_m);
+        if (req.paginate && res.ok) {
+            const proceeed = await req.paginate(res, opt);
+            if (proceeed) {
+                return await this.doFetch(opt);
             }
-            finally { if (e_2) throw e_2.error; }
         }
         return res;
     }
-    async onOkResponse(res, started, timeout) {
+    async onOkResponse(res, timeout) {
         const { req } = res;
         const { mode } = res.req;
         if (mode === 'json') {
@@ -214,7 +187,7 @@ export class Fetcher {
                         // } satisfies HttpRequestErrorData)
                         res.err = _anyToError(err);
                         res.ok = false;
-                        return await this.onNotOkResponse(res, started, timeout);
+                        return await this.onNotOkResponse(res, timeout);
                     }
                 }
                 else {
@@ -242,7 +215,7 @@ export class Fetcher {
             if (res.body === null) {
                 res.err = new Error(`fetchResponse.body is null`);
                 res.ok = false;
-                return await this.onNotOkResponse(res, started, timeout);
+                return await this.onNotOkResponse(res, timeout);
             }
         }
         clearTimeout(timeout);
@@ -256,7 +229,7 @@ export class Fetcher {
                 res.fetchResponse.status,
                 res.signature,
                 retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
-                _since(started),
+                _since(res.req.started),
             ]
                 .filter(Boolean)
                 .join(' '));
@@ -271,7 +244,7 @@ export class Fetcher {
     async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
-    async onNotOkResponse(res, started, timeout) {
+    async onNotOkResponse(res, timeout) {
         var _a, _b;
         clearTimeout(timeout);
         let cause;
@@ -294,39 +267,22 @@ export class Fetcher {
             // Enabled, cause `data` is not printed by default when error is HttpError
             // method: req.method,
             // tryCount: req.tryCount,
-            requestUrl: res.req.url,
+            requestUrl: res.req.fullUrl,
             requestBaseUrl: this.cfg.baseUrl || null,
             requestMethod: res.req.init.method,
             requestSignature: res.signature,
-            requestDuration: Date.now() - started,
+            requestDuration: Date.now() - res.req.started,
         }), cause);
         await this.processRetry(res);
     }
     async processRetry(res) {
-        var _a, e_3, _b, _c;
+        var _a;
         const { retryStatus } = res;
         if (!this.shouldRetry(res)) {
             retryStatus.retryStopped = true;
         }
-        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; }
+        for (const hook of this.cfg.hooks.beforeRetry || []) {
+            await hook(res);
         }
         const { count, timeoutMultiplier, timeoutMax } = res.req.retry;
         if (retryStatus.retryAttempt >= count) {
@@ -334,6 +290,22 @@ export class Fetcher {
         }
         if (retryStatus.retryStopped)
             return;
+        // Here we know that more retries will be attempted
+        // We don't log "last error", because it will be thrown and logged by consumer,
+        // but we should log all previous errors, otherwise they are lost.
+        // Here is the right place where we know it's not the "last error"
+        if (res.err) {
+            const { retryAttempt } = retryStatus;
+            this.cfg.logger.error([
+                ' <<',
+                ((_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status) || 0,
+                res.signature,
+                `try#${retryAttempt + 1}/${count + 1}`,
+                _since(res.req.started),
+            ]
+                .filter(Boolean)
+                .join(' '), res.err.cause || res.err);
+        }
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
         const noise = Math.random() * 500;
@@ -406,7 +378,7 @@ export class Fetcher {
         const { debug = false } = cfg;
         const norm = _merge({
             baseUrl: '',
-            url: '',
+            inputUrl: '',
             mode: 'void',
             searchParams: {},
             timeoutSeconds: 30,
@@ -434,32 +406,31 @@ export class Fetcher {
         norm.init.headers = _mapKeys(norm.init.headers, k => k.toLowerCase());
         return norm;
     }
-    normalizeOptions(url, opt) {
+    normalizeOptions(opt) {
         var _a, _b;
         const { timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry, mode, jsonReviver, } = this.cfg;
-        const req = Object.assign(Object.assign({ mode,
-            url,
+        const req = Object.assign(Object.assign({ started: Date.now(), mode,
             timeoutSeconds,
             throwHttpErrors,
             retryPost,
             retry4xx,
             retry5xx,
-            jsonReviver }, _omit(opt, ['method', 'headers', 'credentials'])), { retry: Object.assign(Object.assign({}, retry), _filterUndefinedValues(opt.retry || {})), init: _merge(Object.assign(Object.assign({}, this.cfg.init), { method: opt.method || this.cfg.init.method, credentials: opt.credentials || this.cfg.init.credentials, redirect: ((_b = (_a = opt.followRedirects) !== null && _a !== void 0 ? _a : this.cfg.followRedirects) !== null && _b !== void 0 ? _b : true) ? 'follow' : 'error' }), {
+            jsonReviver }, _omit(opt, ['method', 'headers', 'credentials'])), { inputUrl: opt.url || '', fullUrl: opt.url || '', retry: Object.assign(Object.assign({}, retry), _filterUndefinedValues(opt.retry || {})), init: _merge(Object.assign(Object.assign({}, this.cfg.init), { method: opt.method || this.cfg.init.method, credentials: opt.credentials || this.cfg.init.credentials, redirect: ((_b = (_a = opt.followRedirects) !== null && _a !== void 0 ? _a : this.cfg.followRedirects) !== null && _b !== void 0 ? _b : true) ? 'follow' : 'error' }), {
                 headers: _mapKeys(opt.headers || {}, k => k.toLowerCase()),
             }) });
         // setup url
         const baseUrl = opt.baseUrl || this.cfg.baseUrl;
         if (baseUrl) {
-            if (url.startsWith('/')) {
+            if (req.fullUrl.startsWith('/')) {
                 console.warn(`Fetcher: url should not start with / when baseUrl is specified`);
-                url = url.slice(1);
+                req.fullUrl = req.fullUrl.slice(1);
             }
-            req.url = `${baseUrl}/${url}`;
+            req.fullUrl = `${baseUrl}/${req.inputUrl}`;
         }
         const searchParams = _filterUndefinedValues(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;
+            req.fullUrl += req.fullUrl.includes('?') ? '&' : '?' + qs;
         }
         // setup request body
         if (opt.json !== undefined) {

package/dist-esm/promise/pMap.js

@@ -6,7 +6,6 @@ Improvements:
 - Included Typescript typings (no need for @types/p-map)
 - Compatible with pProps (that had typings issues)
  */
-import { __asyncValues } from "tslib";
 import { END, ErrorMode, SKIP } from '..';
 /**
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
@@ -35,7 +34,6 @@ import { END, ErrorMode, SKIP } from '..';
  * })();
  */
 export async function pMap(iterable, mapper, opt = {}) {
-    var _a, e_1, _b, _c;
     const ret = [];
     // const iterator = iterable[Symbol.iterator]()
     const items = [...iterable];
@@ -49,40 +47,23 @@ export async function pMap(iterable, mapper, opt = {}) {
     let currentIndex = 0;
     // Special cases that are able to preserve async stack traces
     if (concurrency === 1) {
-        try {
-            // Special case for concurrency == 1
-            for (var _d = true, items_1 = __asyncValues(items), items_1_1; items_1_1 = await items_1.next(), _a = items_1_1.done, !_a;) {
-                _c = items_1_1.value;
-                _d = false;
-                try {
-                    const item = _c;
-                    try {
-                        const r = await mapper(item, currentIndex++);
-                        if (r === END)
-                            break;
-                        if (r !== SKIP)
-                            ret.push(r);
-                    }
-                    catch (err) {
-                        if (errorMode === ErrorMode.THROW_IMMEDIATELY)
-                            throw err;
-                        if (errorMode === ErrorMode.THROW_AGGREGATED) {
-                            errors.push(err);
-                        }
-                        // otherwise, suppress completely
-                    }
-                }
-                finally {
-                    _d = true;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
+        // Special case for concurrency == 1
+        for (const item of items) {
             try {
-                if (!_d && !_a && (_b = items_1.return)) await _b.call(items_1);
+                const r = await mapper(item, currentIndex++);
+                if (r === END)
+                    break;
+                if (r !== SKIP)
+                    ret.push(r);
+            }
+            catch (err) {
+                if (errorMode === ErrorMode.THROW_IMMEDIATELY)
+                    throw err;
+                if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                    errors.push(err);
+                }
+                // otherwise, suppress completely
             }
-            finally { if (e_1) throw e_1.error; }
         }
         if (errors.length) {
             throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);

package/package.json

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

package/src/http/fetcher.model.ts

@@ -1,16 +1,24 @@
 import type { CommonLogger } from '../log/commonLogger'
 import type { Promisable } from '../typeFest'
-import type { Reviver } from '../types'
+import type { Reviver, UnixTimestampMillisNumber } from '../types'
 import type { HttpMethod, HttpStatusFamily } from './http.model'
 
-export interface FetcherNormalizedCfg extends Required<FetcherCfg>, FetcherRequest {
+export interface FetcherNormalizedCfg
+  extends Required<FetcherCfg>,
+    Omit<FetcherRequest, 'started' | 'fullUrl'> {
   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 type FetcherBeforeRequestHook = <BODY = unknown>(
+  req: FetcherRequest<BODY>,
+) => Promisable<void>
+export type FetcherAfterResponseHook = <BODY = unknown>(
+  res: FetcherResponse<BODY>,
+) => Promisable<void>
+export type FetcherBeforeRetryHook = <BODY = unknown>(
+  res: FetcherResponse<BODY>,
+) => Promisable<void>
 
 export interface FetcherCfg {
   /**
@@ -88,8 +96,17 @@ export interface FetcherRetryOptions {
   timeoutMultiplier: number
 }
 
-export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl'> {
-  url: string
+export interface FetcherRequest<BODY = unknown>
+  extends Omit<FetcherOptions<BODY>, 'method' | 'headers' | 'baseUrl' | 'url'> {
+  /**
+   * inputUrl is only the part that was passed in the request,
+   * without baseUrl or searchParams.
+   */
+  inputUrl: string
+  /**
+   * fullUrl includes baseUrl and searchParams.
+   */
+  fullUrl: string
   init: RequestInitNormalized
   mode: FetcherMode
   throwHttpErrors: boolean
@@ -98,11 +115,18 @@ export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers
   retryPost: boolean
   retry4xx: boolean
   retry5xx: boolean
+  started: UnixTimestampMillisNumber
 }
 
-export interface FetcherOptions {
+export interface FetcherOptions<BODY = unknown> {
   method?: HttpMethod
 
+  /**
+   * If defined - this `url` will override the original given `url`.
+   * baseUrl (and searchParams) will still modify it.
+   */
+  url?: string
+
   baseUrl?: string
 
   throwHttpErrors?: boolean
@@ -159,6 +183,22 @@ export interface FetcherOptions {
   retry5xx?: boolean
 
   jsonReviver?: Reviver
+
+  /**
+   * Allows to walk over multiple pages of results.
+   * Paginate take a function.
+   * Function has access to FetcherResponse and FetcherOptions
+   * and has to make a decision to continue pagination or not.
+   *
+   * Return false to stop pagination.
+   * Return true to continue pagination.
+   * Feel free to mutate/modify opt (FetcherOptions), for example:
+   *
+   * opt.searchParams!['page']++
+   *
+   * @experimental
+   */
+  paginate?: (res: FetcherSuccessResponse<BODY>, opt: FetcherOptions<BODY>) => Promisable<boolean>
 }
 
 export type RequestInitNormalized = Omit<RequestInit, 'method' | 'headers'> & {

package/src/http/fetcher.ts

@@ -15,7 +15,6 @@ import {
 import { pDelay } from '../promise/pDelay'
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util'
 import { _since } from '../time/time.util'
-import { UnixTimestampNumber } from '../types'
 import type {
   FetcherAfterResponseHook,
   FetcherBeforeRequestHook,
@@ -54,8 +53,12 @@ export class Fetcher {
       const m = method.toLowerCase()
 
       // mode=void
-      ;(this as any)[`${m}Void`] = async (url: string, opt?: FetcherOptions): Promise<void> => {
-        return await this.fetch<void>(url, {
+      ;(this as any)[`${m}Void`] = async (
+        url: string,
+        opt?: FetcherOptions<void>,
+      ): Promise<void> => {
+        return await this.fetch<void>({
+          url,
           method,
           mode: 'void',
           ...opt,
@@ -63,8 +66,12 @@ export class Fetcher {
       }
 
       if (method === 'HEAD') return // mode=text
-      ;(this as any)[`${m}Text`] = async (url: string, opt?: FetcherOptions): Promise<string> => {
-        return await this.fetch<string>(url, {
+      ;(this as any)[`${m}Text`] = async (
+        url: string,
+        opt?: FetcherOptions<string>,
+      ): Promise<string> => {
+        return await this.fetch<string>({
+          url,
           method,
           mode: 'text',
           ...opt,
@@ -72,8 +79,9 @@ export class Fetcher {
       }
 
       // Default mode=json, but overridable
-      ;(this as any)[m] = async <T = unknown>(url: string, opt?: FetcherOptions): Promise<T> => {
-        return await this.fetch<T>(url, {
+      ;(this as any)[m] = async <T = unknown>(url: string, opt?: FetcherOptions<T>): Promise<T> => {
+        return await this.fetch<T>({
+          url,
           method,
           mode: 'json',
           ...opt,
@@ -108,26 +116,26 @@ export class Fetcher {
 
   // These methods are generated dynamically in the constructor
   // These default methods use mode=json
-  get!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
-  post!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
-  put!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
-  patch!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
-  delete!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  get!: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>
+  post!: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>
+  put!: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>
+  patch!: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>
+  delete!: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>
 
   // mode=text
-  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>
+  getText!: (url: string, opt?: FetcherOptions<string>) => Promise<string>
+  postText!: (url: string, opt?: FetcherOptions<string>) => Promise<string>
+  putText!: (url: string, opt?: FetcherOptions<string>) => Promise<string>
+  patchText!: (url: string, opt?: FetcherOptions<string>) => Promise<string>
+  deleteText!: (url: string, opt?: FetcherOptions<string>) => Promise<string>
 
   // mode=void (no body fetching/parsing)
-  getVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
-  postVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
-  putVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
-  patchVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
-  deleteVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
-  headVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
+  getVoid!: (url: string, opt?: FetcherOptions<void>) => Promise<void>
+  postVoid!: (url: string, opt?: FetcherOptions<void>) => Promise<void>
+  putVoid!: (url: string, opt?: FetcherOptions<void>) => Promise<void>
+  patchVoid!: (url: string, opt?: FetcherOptions<void>) => Promise<void>
+  deleteVoid!: (url: string, opt?: FetcherOptions<void>) => Promise<void>
+  headVoid!: (url: string, opt?: FetcherOptions<void>) => Promise<void>
 
   // mode=readableStream
   /**
@@ -136,15 +144,19 @@ export class Fetcher {
    * More on streams and Node interop:
    * https://css-tricks.com/web-streams-everywhere-and-fetch-for-node-js/
    */
-  async getReadableStream(url: string, opt?: FetcherOptions): Promise<ReadableStream<Uint8Array>> {
-    return await this.fetch(url, {
+  async getReadableStream(
+    url: string,
+    opt?: FetcherOptions<ReadableStream<Uint8Array>>,
+  ): Promise<ReadableStream<Uint8Array>> {
+    return await this.fetch({
+      url,
       mode: 'readableStream',
       ...opt,
     })
   }
 
-  async fetch<T = unknown>(url: string, opt?: FetcherOptions): Promise<T> {
-    const res = await this.doFetch<T>(url, opt)
+  async fetch<T = unknown>(opt: FetcherOptions<T>): Promise<T> {
+    const res = await this.doFetch<T>(opt)
     if (res.err) {
       if (res.req.throwHttpErrors) throw res.err
       return res as any
@@ -157,13 +169,9 @@ export class Fetcher {
    * Never throws, returns `err` property in the response instead.
    * Use this method instead of `throwHttpErrors: false` or try-catching.
    */
-  async doFetch<T = unknown>(
-    url: string,
-    rawOpt: FetcherOptions = {},
-  ): Promise<FetcherResponse<T>> {
+  async doFetch<T = unknown>(opt: FetcherOptions<T>): Promise<FetcherResponse<T>> {
+    const req = this.normalizeOptions(opt)
     const { logger } = this.cfg
-
-    const req = this.normalizeOptions(url, rawOpt)
     const {
       timeoutSeconds,
       init: { method },
@@ -179,13 +187,13 @@ export class Fetcher {
       }, timeoutSeconds * 1000) as any as number
     }
 
-    for await (const hook of this.cfg.hooks.beforeRequest || []) {
+    for (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 isFullUrl = req.fullUrl.includes('://')
+    const fullUrl = isFullUrl ? new URL(req.fullUrl) : undefined
+    const shortUrl = fullUrl ? this.getShortUrl(fullUrl) : req.fullUrl
     const signature = [method, shortUrl].join(' ')
 
     const res = {
@@ -199,7 +207,7 @@ export class Fetcher {
     } as FetcherResponse<any>
 
     while (!res.retryStatus.retryStopped) {
-      const started = Date.now()
+      req.started = Date.now()
 
       if (this.cfg.logRequest) {
         const { retryAttempt } = res.retryStatus
@@ -214,7 +222,7 @@ export class Fetcher {
       }
 
       try {
-        res.fetchResponse = await this.callNativeFetch(req.url, req.init)
+        res.fetchResponse = await this.callNativeFetch(req.fullUrl, req.init)
         res.ok = res.fetchResponse.ok
       } catch (err) {
         // For example, CORS error would result in "TypeError: failed to fetch" here
@@ -226,27 +234,29 @@ export class Fetcher {
       res.statusFamily = this.getStatusFamily(res)
 
       if (res.fetchResponse?.ok) {
-        await this.onOkResponse(
-          res as FetcherResponse<T> & { fetchResponse: Response },
-          started,
-          timeout,
-        )
+        await this.onOkResponse(res as FetcherResponse<T> & { fetchResponse: Response }, timeout)
       } else {
         // !res.ok
-        await this.onNotOkResponse(res, started, timeout)
+        await this.onNotOkResponse(res, timeout)
       }
     }
 
-    for await (const hook of this.cfg.hooks.afterResponse || []) {
+    for (const hook of this.cfg.hooks.afterResponse || []) {
       await hook(res)
     }
 
+    if (req.paginate && res.ok) {
+      const proceeed = await req.paginate(res, opt)
+      if (proceeed) {
+        return await this.doFetch(opt)
+      }
+    }
+
     return res
   }
 
   private async onOkResponse(
     res: FetcherResponse<any> & { fetchResponse: Response },
-    started: UnixTimestampNumber,
     timeout?: number,
   ): Promise<void> {
     const { req } = res
@@ -273,7 +283,7 @@ export class Fetcher {
             res.err = _anyToError(err)
             res.ok = false
 
-            return await this.onNotOkResponse(res, started, timeout)
+            return await this.onNotOkResponse(res, timeout)
           }
         } else {
           // Body had a '' (empty string)
@@ -296,7 +306,7 @@ export class Fetcher {
       if (res.body === null) {
         res.err = new Error(`fetchResponse.body is null`)
         res.ok = false
-        return await this.onNotOkResponse(res, started, timeout)
+        return await this.onNotOkResponse(res, timeout)
       }
     }
 
@@ -313,7 +323,7 @@ export class Fetcher {
           res.fetchResponse.status,
           res.signature,
           retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
-          _since(started),
+          _since(res.req.started),
         ]
           .filter(Boolean)
           .join(' '),
@@ -332,11 +342,7 @@ export class Fetcher {
     return await globalThis.fetch(url, init)
   }
 
-  private async onNotOkResponse(
-    res: FetcherResponse,
-    started: UnixTimestampNumber,
-    timeout?: number,
-  ): Promise<void> {
+  private async onNotOkResponse(res: FetcherResponse, timeout?: number): Promise<void> {
     clearTimeout(timeout)
 
     let cause: ErrorObject | undefined
@@ -363,11 +369,11 @@ export class Fetcher {
         // Enabled, cause `data` is not printed by default when error is HttpError
         // method: req.method,
         // tryCount: req.tryCount,
-        requestUrl: res.req.url,
+        requestUrl: res.req.fullUrl,
         requestBaseUrl: this.cfg.baseUrl || (null as any),
         requestMethod: res.req.init.method,
         requestSignature: res.signature,
-        requestDuration: Date.now() - started,
+        requestDuration: Date.now() - res.req.started,
       }),
       cause,
     )
@@ -382,7 +388,7 @@ export class Fetcher {
       retryStatus.retryStopped = true
     }
 
-    for await (const hook of this.cfg.hooks.beforeRetry || []) {
+    for (const hook of this.cfg.hooks.beforeRetry || []) {
       await hook(res)
     }
 
@@ -394,6 +400,26 @@ export class Fetcher {
 
     if (retryStatus.retryStopped) return
 
+    // Here we know that more retries will be attempted
+    // We don't log "last error", because it will be thrown and logged by consumer,
+    // but we should log all previous errors, otherwise they are lost.
+    // Here is the right place where we know it's not the "last error"
+    if (res.err) {
+      const { retryAttempt } = retryStatus
+      this.cfg.logger.error(
+        [
+          ' <<',
+          res.fetchResponse?.status || 0,
+          res.signature,
+          `try#${retryAttempt + 1}/${count + 1}`,
+          _since(res.req.started),
+        ]
+          .filter(Boolean)
+          .join(' '),
+        res.err.cause || res.err,
+      )
+    }
+
     retryStatus.retryAttempt++
     retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax)
 
@@ -466,7 +492,7 @@ export class Fetcher {
     const norm: FetcherNormalizedCfg = _merge(
       {
         baseUrl: '',
-        url: '',
+        inputUrl: '',
         mode: 'void',
         searchParams: {},
         timeoutSeconds: 30,
@@ -499,7 +525,7 @@ export class Fetcher {
     return norm
   }
 
-  private normalizeOptions(url: string, opt: FetcherOptions): FetcherRequest {
+  private normalizeOptions<BODY>(opt: FetcherOptions<BODY>): FetcherRequest<BODY> {
     const {
       timeoutSeconds,
       throwHttpErrors,
@@ -511,9 +537,9 @@ export class Fetcher {
       jsonReviver,
     } = this.cfg
 
-    const req: FetcherRequest = {
+    const req: FetcherRequest<BODY> = {
+      started: Date.now(),
       mode,
-      url,
       timeoutSeconds,
       throwHttpErrors,
       retryPost,
@@ -521,6 +547,8 @@ export class Fetcher {
       retry5xx,
       jsonReviver,
       ..._omit(opt, ['method', 'headers', 'credentials']),
+      inputUrl: opt.url || '',
+      fullUrl: opt.url || '',
       retry: {
         ...retry,
         ..._filterUndefinedValues(opt.retry || {}),
@@ -541,11 +569,11 @@ export class Fetcher {
     // setup url
     const baseUrl = opt.baseUrl || this.cfg.baseUrl
     if (baseUrl) {
-      if (url.startsWith('/')) {
+      if (req.fullUrl.startsWith('/')) {
         console.warn(`Fetcher: url should not start with / when baseUrl is specified`)
-        url = url.slice(1)
+        req.fullUrl = req.fullUrl.slice(1)
       }
-      req.url = `${baseUrl}/${url}`
+      req.fullUrl = `${baseUrl}/${req.inputUrl}`
     }
 
     const searchParams = _filterUndefinedValues({
@@ -555,7 +583,7 @@ export class Fetcher {
 
     if (Object.keys(searchParams).length) {
       const qs = new URLSearchParams(searchParams).toString()
-      req.url += req.url.includes('?') ? '&' : '?' + qs
+      req.fullUrl += req.fullUrl.includes('?') ? '&' : '?' + qs
     }
 
     // setup request body

package/src/promise/pMap.ts

@@ -77,7 +77,7 @@ export async function pMap<IN, OUT>(
   if (concurrency === 1) {
     // Special case for concurrency == 1
 
-    for await (const item of items) {
+    for (const item of items) {
       try {
         const r = await mapper(item, currentIndex++)
         if (r === END) break