@nxtedition/lib 14.1.0 → 14.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "14.1.0",
+  "version": "14.1.1",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "files": [

package/undici.js

@@ -1,29 +1,114 @@
-import * as undici from 'undici'
-import xuid from 'xuid'
+const assert = require('assert')
+const tp = require('timers/promises')
+const xuid = require('xuid')
+const { isReadableNodeStream } = require('./stream')
+const undici = require('undici')
+const stream = require('stream')
 
-export async function request(url, { logger, ...options }) {
+module.exports.request = async function request(
+  url,
+  {
+    logger,
+    id = xuid(),
+    retry: { count: maxRetries = 8 } = {},
+    redirect: { count: maxRedirections = 3 } = {},
+    dispatcher,
+    signal,
+    method = 'GET',
+    body,
+    userAgent,
+    headers,
+  }
+) {
   const ureq = {
     url,
-    maxRedirections: 3,
+    method,
+    body,
     headers: {
-      'req-id': xuid(),
-      'user-agent': options.userAgent,
-      ...options.headers,
+      'req-id': id,
+      'user-agent': userAgent,
+      ...headers,
     },
-    ...options,
-    throwOnError: true,
   }
 
-  logger?.debug({ ureq }, 'upstream request started')
+  const upstreamLogger = logger?.child({ ureq })
 
-  const ures = await undici.request(url, options)
+  upstreamLogger?.debug({ ureq }, 'upstream request started')
 
-  logger?.debug({ ureq, ures }, 'upstream request response')
+  try {
+    /* eslint-disable no-unreachable-loop */
+    for (let retryCount = 0; true; retryCount++) {
+      try {
+        const ures = await undici.request(url, {
+          method,
+          body,
+          headers,
+          signal,
+          dispatcher,
+          maxRedirections,
+          throwOnError: true,
+        })
 
-  if (ures.statusCode >= 300 && ures.statusCode < 400) {
-    await ures.body.dump()
-    throw new Error('maxRedirections exceeded')
-  }
+        upstreamLogger?.debug({ ureq, ures }, 'upstream request response')
+
+        if (ures.statusCode >= 300 && ures.statusCode < 400) {
+          await ures.body.dump()
+          throw new Error('maxRedirections exceeded')
+        }
+
+        assert(ures.statusCode >= 200 && ures.statusCode < 300)
+
+        // TODO (fix): Wrap response to handle error that can continue with range request...
+
+        return ures
+      } catch (err) {
+        if (retryCount >= maxRetries) {
+          throw err
+        }
 
-  return ures
+        if (
+          body != null &&
+          typeof body !== 'string' &&
+          !Buffer.isBuffer(body) &&
+          (!isReadableNodeStream(body) || stream.isDisturbed(body))
+        ) {
+          throw err
+        }
+
+        if (method === 'HEAD' || method === 'GET') {
+          if (
+            err.code !== 'ECONNRESET' &&
+            err.code !== 'ECONNREFUSED' &&
+            err.code !== 'ENOTFOUND' &&
+            err.code !== 'ENETDOWN' &&
+            err.code !== 'ENETUNREACH' &&
+            err.code !== 'EHOSTDOWN' &&
+            err.code !== 'EHOSTUNREACH' &&
+            err.code !== 'EPIPE' &&
+            err.message !== 'other side closed' &&
+            err.statusCode !== 420 &&
+            err.statusCode !== 429 &&
+            err.statusCode !== 502 &&
+            err.statusCode !== 503 &&
+            err.statusCode !== 504
+          ) {
+            throw err
+          }
+        } else {
+          // TODO (fix): What to do?
+          throw err
+        }
+
+        const delay =
+          parseInt(err.headers?.['Retry-After']) * 1e3 || Math.min(10e3, retryCount * 1e3 + 1e3)
+
+        logger?.warn({ err, retryCount, delay }, 'upstream request retrying')
+
+        return tp.setTimeout(delay, undefined, { signal })
+      }
+    }
+  } catch (err) {
+    logger?.error({ err }, 'upstream request failed')
+    throw err
+  }
 }