@naturalcycles/js-lib 14.147.0 → 14.148.0

package/dist/http/fetcher.d.ts

@@ -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
@@ -308,12 +310,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 +322,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-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
@@ -295,12 +297,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 +309,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.148.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

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,
@@ -224,6 +225,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
@@ -405,13 +408,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 +425,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
   }
 
   /**