@naturalcycles/js-lib 14.147.0 → 14.149.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<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>;
+    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>;
     /**
      * 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<ReadableStream<Uint8Array>>): Promise<ReadableStream<Uint8Array>>;
-    fetch<T = unknown>(opt: FetcherOptions<T>): Promise<T>;
+    getReadableStream(url: string, opt?: FetcherOptions): Promise<ReadableStream<Uint8Array>>;
+    fetch<T = unknown>(opt: FetcherOptions): 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>(opt: FetcherOptions<T>): Promise<FetcherResponse<T>>;
+    doFetch<T = unknown>(opt: FetcherOptions): Promise<FetcherResponse<T>>;
     private onOkResponse;
     /**
      * This method exists to be able to easily mock it.
@@ -51,6 +51,7 @@ export declare class Fetcher {
     callNativeFetch(url: string, init: RequestInit): Promise<Response>;
     private onNotOkResponse;
     private processRetry;
+    private getRetryTimeout;
     /**
      * Default is yes,
      * unless there's reason not to (e.g method is POST).

package/dist/http/fetcher.js

@@ -151,6 +151,8 @@ class Fetcher {
             try {
                 res.fetchResponse = await this.callNativeFetch(req.fullUrl, req.init);
                 res.ok = res.fetchResponse.ok;
+                // important to set it to undefined, otherwise it can keep the previous value (from previous try)
+                res.err = undefined;
             }
             catch (err) {
                 // For example, CORS error would result in "TypeError: failed to fetch" here
@@ -171,12 +173,6 @@ class Fetcher {
         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, timeout) {
@@ -308,12 +304,11 @@ class Fetcher {
         // 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}`,
+                `try#${retryStatus.retryAttempt + 1}/${count + 1}`,
                 (0, time_util_1._since)(res.req.started),
             ]
                 .filter(Boolean)
@@ -321,8 +316,36 @@ class Fetcher {
         }
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = (0, number_util_1._clamp)(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
-        const noise = Math.random() * 500;
-        await (0, pDelay_1.pDelay)(retryStatus.retryTimeout + noise);
+        await (0, pDelay_1.pDelay)(this.getRetryTimeout(res));
+    }
+    getRetryTimeout(res) {
+        let timeout = 0;
+        // Handling http 429 with specific retry headers
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+        if (res.fetchResponse && [429, 503].includes(res.fetchResponse.status)) {
+            const retryAfterStr = res.fetchResponse.headers.get('retry-after') ??
+                res.fetchResponse.headers.get('x-ratelimit-reset');
+            if (retryAfterStr) {
+                if (Number(retryAfterStr)) {
+                    timeout = Number(retryAfterStr) * 1000;
+                }
+                else {
+                    const date = new Date(retryAfterStr);
+                    if (!isNaN(date)) {
+                        timeout = Number(date) - Date.now();
+                    }
+                }
+                this.cfg.logger.log(`retry-after: ${retryAfterStr}`);
+                if (!timeout) {
+                    this.cfg.logger.warn(`retry-after could not be parsed`);
+                }
+            }
+        }
+        if (!timeout) {
+            const noise = Math.random() * 500;
+            timeout = res.retryStatus.retryTimeout + noise;
+        }
+        return timeout;
     }
     /**
      * Default is yes,

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

@@ -6,7 +6,7 @@ export interface FetcherNormalizedCfg extends Required<FetcherCfg>, Omit<Fetcher
     logger: CommonLogger;
     searchParams: Record<string, any>;
 }
-export type FetcherBeforeRequestHook = <BODY = unknown>(req: FetcherRequest<BODY>) => Promisable<void>;
+export type FetcherBeforeRequestHook = (req: FetcherRequest) => 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 {
@@ -77,7 +77,7 @@ export interface FetcherRetryOptions {
     timeoutMax: number;
     timeoutMultiplier: number;
 }
-export interface FetcherRequest<BODY = unknown> extends Omit<FetcherOptions<BODY>, 'method' | 'headers' | 'baseUrl' | 'url'> {
+export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl' | 'url'> {
     /**
      * inputUrl is only the part that was passed in the request,
      * without baseUrl or searchParams.
@@ -97,7 +97,7 @@ export interface FetcherRequest<BODY = unknown> extends Omit<FetcherOptions<BODY
     retry5xx: boolean;
     started: UnixTimestampMillisNumber;
 }
-export interface FetcherOptions<BODY = unknown> {
+export interface FetcherOptions {
     method?: HttpMethod;
     /**
      * If defined - this `url` will override the original given `url`.
@@ -148,21 +148,6 @@ export interface FetcherOptions<BODY = unknown> {
      */
     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-esm/http/fetcher.js

@@ -136,6 +136,8 @@ export class Fetcher {
             try {
                 res.fetchResponse = await this.callNativeFetch(req.fullUrl, req.init);
                 res.ok = res.fetchResponse.ok;
+                // important to set it to undefined, otherwise it can keep the previous value (from previous try)
+                res.err = undefined;
             }
             catch (err) {
                 // For example, CORS error would result in "TypeError: failed to fetch" here
@@ -156,12 +158,6 @@ export class Fetcher {
         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, timeout) {
@@ -295,12 +291,11 @@ export class Fetcher {
         // 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}`,
+                `try#${retryStatus.retryAttempt + 1}/${count + 1}`,
                 _since(res.req.started),
             ]
                 .filter(Boolean)
@@ -308,8 +303,36 @@ export class Fetcher {
         }
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
-        const noise = Math.random() * 500;
-        await pDelay(retryStatus.retryTimeout + noise);
+        await pDelay(this.getRetryTimeout(res));
+    }
+    getRetryTimeout(res) {
+        var _a;
+        let timeout = 0;
+        // Handling http 429 with specific retry headers
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+        if (res.fetchResponse && [429, 503].includes(res.fetchResponse.status)) {
+            const retryAfterStr = (_a = res.fetchResponse.headers.get('retry-after')) !== null && _a !== void 0 ? _a : res.fetchResponse.headers.get('x-ratelimit-reset');
+            if (retryAfterStr) {
+                if (Number(retryAfterStr)) {
+                    timeout = Number(retryAfterStr) * 1000;
+                }
+                else {
+                    const date = new Date(retryAfterStr);
+                    if (!isNaN(date)) {
+                        timeout = Number(date) - Date.now();
+                    }
+                }
+                this.cfg.logger.log(`retry-after: ${retryAfterStr}`);
+                if (!timeout) {
+                    this.cfg.logger.warn(`retry-after could not be parsed`);
+                }
+            }
+        }
+        if (!timeout) {
+            const noise = Math.random() * 500;
+            timeout = res.retryStatus.retryTimeout + noise;
+        }
+        return timeout;
     }
     /**
      * Default is yes,

package/package.json

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

package/src/http/fetcher.model.ts

@@ -10,9 +10,7 @@ export interface FetcherNormalizedCfg
   searchParams: Record<string, any>
 }
 
-export type FetcherBeforeRequestHook = <BODY = unknown>(
-  req: FetcherRequest<BODY>,
-) => Promisable<void>
+export type FetcherBeforeRequestHook = (req: FetcherRequest) => Promisable<void>
 export type FetcherAfterResponseHook = <BODY = unknown>(
   res: FetcherResponse<BODY>,
 ) => Promisable<void>
@@ -96,8 +94,8 @@ export interface FetcherRetryOptions {
   timeoutMultiplier: number
 }
 
-export interface FetcherRequest<BODY = unknown>
-  extends Omit<FetcherOptions<BODY>, 'method' | 'headers' | 'baseUrl' | 'url'> {
+export interface FetcherRequest
+  extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl' | 'url'> {
   /**
    * inputUrl is only the part that was passed in the request,
    * without baseUrl or searchParams.
@@ -118,7 +116,7 @@ export interface FetcherRequest<BODY = unknown>
   started: UnixTimestampMillisNumber
 }
 
-export interface FetcherOptions<BODY = unknown> {
+export interface FetcherOptions {
   method?: HttpMethod
 
   /**
@@ -183,22 +181,6 @@ export interface FetcherOptions<BODY = unknown> {
   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,6 +15,7 @@ import {
 import { pDelay } from '../promise/pDelay'
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util'
 import { _since } from '../time/time.util'
+import { NumberOfMilliseconds } from '../types'
 import type {
   FetcherAfterResponseHook,
   FetcherBeforeRequestHook,
@@ -53,10 +54,7 @@ export class Fetcher {
       const m = method.toLowerCase()
 
       // mode=void
-      ;(this as any)[`${m}Void`] = async (
-        url: string,
-        opt?: FetcherOptions<void>,
-      ): Promise<void> => {
+      ;(this as any)[`${m}Void`] = async (url: string, opt?: FetcherOptions): Promise<void> => {
         return await this.fetch<void>({
           url,
           method,
@@ -66,10 +64,7 @@ export class Fetcher {
       }
 
       if (method === 'HEAD') return // mode=text
-      ;(this as any)[`${m}Text`] = async (
-        url: string,
-        opt?: FetcherOptions<string>,
-      ): Promise<string> => {
+      ;(this as any)[`${m}Text`] = async (url: string, opt?: FetcherOptions): Promise<string> => {
         return await this.fetch<string>({
           url,
           method,
@@ -79,7 +74,7 @@ export class Fetcher {
       }
 
       // Default mode=json, but overridable
-      ;(this as any)[m] = async <T = unknown>(url: string, opt?: FetcherOptions<T>): Promise<T> => {
+      ;(this as any)[m] = async <T = unknown>(url: string, opt?: FetcherOptions): Promise<T> => {
         return await this.fetch<T>({
           url,
           method,
@@ -116,26 +111,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<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>
+  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>
 
   // mode=text
-  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>
+  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>
 
   // mode=void (no body fetching/parsing)
-  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>
+  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>
 
   // mode=readableStream
   /**
@@ -144,10 +139,7 @@ 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<ReadableStream<Uint8Array>>,
-  ): Promise<ReadableStream<Uint8Array>> {
+  async getReadableStream(url: string, opt?: FetcherOptions): Promise<ReadableStream<Uint8Array>> {
     return await this.fetch({
       url,
       mode: 'readableStream',
@@ -155,7 +147,7 @@ export class Fetcher {
     })
   }
 
-  async fetch<T = unknown>(opt: FetcherOptions<T>): Promise<T> {
+  async fetch<T = unknown>(opt: FetcherOptions): Promise<T> {
     const res = await this.doFetch<T>(opt)
     if (res.err) {
       if (res.req.throwHttpErrors) throw res.err
@@ -169,7 +161,7 @@ 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>(opt: FetcherOptions<T>): Promise<FetcherResponse<T>> {
+  async doFetch<T = unknown>(opt: FetcherOptions): Promise<FetcherResponse<T>> {
     const req = this.normalizeOptions(opt)
     const { logger } = this.cfg
     const {
@@ -224,6 +216,8 @@ export class Fetcher {
       try {
         res.fetchResponse = await this.callNativeFetch(req.fullUrl, req.init)
         res.ok = res.fetchResponse.ok
+        // important to set it to undefined, otherwise it can keep the previous value (from previous try)
+        res.err = undefined
       } catch (err) {
         // For example, CORS error would result in "TypeError: failed to fetch" here
         res.err = err as Error
@@ -245,13 +239,6 @@ export class Fetcher {
       await hook(res)
     }
 
-    if (req.paginate && res.ok) {
-      const proceeed = await req.paginate(res, opt)
-      if (proceeed) {
-        return await this.doFetch(opt)
-      }
-    }
-
     return res
   }
 
@@ -405,13 +392,12 @@ export class Fetcher {
     // 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}`,
+          `try#${retryStatus.retryAttempt + 1}/${count + 1}`,
           _since(res.req.started),
         ]
           .filter(Boolean)
@@ -423,8 +409,41 @@ export class Fetcher {
     retryStatus.retryAttempt++
     retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax)
 
-    const noise = Math.random() * 500
-    await pDelay(retryStatus.retryTimeout + noise)
+    await pDelay(this.getRetryTimeout(res))
+  }
+
+  private getRetryTimeout(res: FetcherResponse): NumberOfMilliseconds {
+    let timeout: NumberOfMilliseconds = 0
+
+    // Handling http 429 with specific retry headers
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+    if (res.fetchResponse && [429, 503].includes(res.fetchResponse.status)) {
+      const retryAfterStr =
+        res.fetchResponse.headers.get('retry-after') ??
+        res.fetchResponse.headers.get('x-ratelimit-reset')
+      if (retryAfterStr) {
+        if (Number(retryAfterStr)) {
+          timeout = Number(retryAfterStr) * 1000
+        } else {
+          const date = new Date(retryAfterStr)
+          if (!isNaN(date as any)) {
+            timeout = Number(date) - Date.now()
+          }
+        }
+
+        this.cfg.logger.log(`retry-after: ${retryAfterStr}`)
+        if (!timeout) {
+          this.cfg.logger.warn(`retry-after could not be parsed`)
+        }
+      }
+    }
+
+    if (!timeout) {
+      const noise = Math.random() * 500
+      timeout = res.retryStatus.retryTimeout + noise
+    }
+
+    return timeout
   }
 
   /**
@@ -525,7 +544,7 @@ export class Fetcher {
     return norm
   }
 
-  private normalizeOptions<BODY>(opt: FetcherOptions<BODY>): FetcherRequest<BODY> {
+  private normalizeOptions(opt: FetcherOptions): FetcherRequest {
     const {
       timeoutSeconds,
       throwHttpErrors,
@@ -537,7 +556,7 @@ export class Fetcher {
       jsonReviver,
     } = this.cfg
 
-    const req: FetcherRequest<BODY> = {
+    const req: FetcherRequest = {
       started: Date.now(),
       mode,
       timeoutSeconds,