@nxtedition/lib 14.3.0 → 15.0.0

package/undici/interceptor/response-body-retry.js

@@ -0,0 +1,155 @@
+const assert = require('node:assert')
+const {
+  parseContentRange,
+  isDisturbed,
+  findHeader,
+  retryAfter: retryAfterFn,
+} = require('../utils.js')
+
+class Handler {
+  constructor(opts, { dispatch, handler }) {
+    this.dispatch = dispatch
+    this.handler = handler
+    this.opts = opts
+    this.abort = null
+    this.aborted = false
+    this.reason = null
+
+    this.count = 0
+    this.pos = 0
+    this.end = null
+    this.error = null
+    this.etag = null
+
+    this.handler.onConnect((reason) => {
+      this.aborted = true
+      if (this.abort) {
+        this.abort(reason)
+      } else {
+        this.reason = reason
+      }
+    })
+  }
+
+  onConnect(abort) {
+    if (this.aborted) {
+      abort(this.reason)
+    } else {
+      this.abort = abort
+    }
+  }
+
+  onBodySent(chunk) {
+    return this.handler.onBodySent(chunk)
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+    const etag = findHeader(rawHeaders, 'etag')
+
+    if (this.resume) {
+      this.resume = null
+
+      // TODO (fix): Support other statusCode with skip?
+      if (statusCode !== 206) {
+        throw this.error
+      }
+
+      // TODO (fix): strict vs weak etag?
+      if (this.etag == null || this.etag !== etag) {
+        throw this.error
+      }
+
+      const contentRange = parseContentRange(findHeader(rawHeaders, 'content-range'))
+      if (!contentRange) {
+        throw this.error
+      }
+
+      const { start, size, end = size } = contentRange
+
+      assert(this.pos === start, 'content-range mismatch')
+      assert(this.end == null || this.end === end, 'content-range mismatch')
+
+      this.resume = resume
+      return true
+    }
+
+    if (this.end == null) {
+      if (statusCode === 206) {
+        const contentRange = parseContentRange(findHeader(rawHeaders, 'content-range'))
+        if (!contentRange) {
+          return this.handler.onHeaders(statusCode, rawHeaders, () => this.resume(), statusMessage)
+        }
+
+        const { start, size, end = size } = contentRange
+
+        this.end = end
+        this.pos = Number(start)
+      } else {
+        const contentLength = findHeader(rawHeaders, 'content-length')
+        if (contentLength) {
+          this.end = Number(contentLength)
+        }
+      }
+
+      assert(Number.isFinite(this.pos))
+      assert(this.end == null || Number.isFinite(this.end), 'invalid content-length')
+    }
+
+    this.etag = etag
+    this.resume = resume
+    return this.handler.onHeaders(statusCode, rawHeaders, () => this.resume(), statusMessage)
+  }
+
+  onData(chunk) {
+    this.pos += chunk.length
+    this.count = 0
+    return this.handler.onData(chunk)
+  }
+
+  onComplete(rawTrailers) {
+    return this.handler.onComplete(rawTrailers)
+  }
+
+  onError(err) {
+    if (this.timeout) {
+      clearTimeout(this.timeout)
+      this.timeout = null
+    }
+
+    if (!this.resume || this.aborted || !this.etag || isDisturbed(this.opts.body)) {
+      return this.handler.onError(err)
+    }
+
+    const retryAfter = retryAfterFn(err, this.count++, this.opts)
+    if (retryAfter == null) {
+      return this.handler.onError(err)
+    }
+    assert(Number.isFinite(retryAfter), 'invalid retry')
+
+    this.error = err
+    this.opts = {
+      ...this.opts,
+      headers: {
+        ...this.opts.headers,
+        range: `bytes=${this.pos}-${this.end ?? ''}`,
+      },
+    }
+
+    this.opts.logger?.debug('retrying response body', { retryAfter })
+
+    this.timeout = setTimeout(() => {
+      this.timeout = null
+      try {
+        this.dispatch(this.opts, this)
+      } catch (err) {
+        this.handler.onError(err)
+      }
+    }, retryAfter)
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) => {
+  return opts.idempotent && opts.retry && opts.method === 'GET'
+    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
+    : dispatch(opts, handler)
+}

package/undici/interceptor/response-retry.js

@@ -0,0 +1,84 @@
+const assert = require('node:assert')
+const { isDisturbed, retryAfter: retryAfterFn } = require('../utils.js')
+
+class Handler {
+  constructor(opts, { dispatch, handler }) {
+    this.dispatch = dispatch
+    this.handler = handler
+    this.opts = opts
+    this.abort = null
+    this.aborted = false
+    this.reason = null
+    this.timeout = null
+    this.count = 0
+    this.retryAfter = null
+
+    this.handler.onConnect((reason) => {
+      this.aborted = true
+      if (this.abort) {
+        this.abort(reason)
+      } else {
+        this.reason = reason
+      }
+    })
+  }
+
+  onConnect(abort) {
+    if (this.aborted) {
+      abort(this.reason)
+    } else {
+      this.abort = abort
+    }
+  }
+
+  onBodySent(chunk) {
+    return this.handler.onBodySent(chunk)
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+    this.aborted = true
+    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+  }
+
+  onData(chunk) {
+    return this.handler.onData(chunk)
+  }
+
+  onComplete(rawTrailers) {
+    return this.handler.onComplete(rawTrailers)
+  }
+
+  onError(err) {
+    if (this.timeout) {
+      clearTimeout(this.timeout)
+      this.timeout = null
+    }
+
+    if (this.aborted || isDisturbed(this.opts.body)) {
+      return this.handler.onError(err)
+    }
+
+    const retryAfter = retryAfterFn(err, this.count++, this.opts)
+    if (retryAfter == null) {
+      return this.handler.onError(err)
+    }
+    assert(Number.isFinite(retryAfter), 'invalid retryAfter')
+
+    this.opts.logger?.debug('retrying response', { retryAfter })
+
+    this.timeout = setTimeout(() => {
+      this.timeout = null
+      try {
+        this.dispatch(this.opts, this)
+      } catch (err2) {
+        this.handler.onError(err)
+      }
+    }, retryAfter)
+    this.retryAfter = null
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) =>
+  opts.idempotent && opts.retry
+    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
+    : dispatch(opts, handler)

package/undici/interceptor/response-status-retry.js

@@ -0,0 +1,96 @@
+const assert = require('node:assert')
+const { isDisturbed, retryAfter: retryAfterFn } = require('../utils')
+const createError = require('http-errors')
+const { parseHeaders } = require('../../http')
+
+class Handler {
+  constructor(opts, { dispatch, handler }) {
+    this.dispatch = dispatch
+    this.handler = handler
+    this.opts = opts
+    this.abort = null
+    this.aborted = false
+    this.reason = null
+
+    this.timeout = null
+    this.count = 0
+    this.retryAfter = null
+
+    this.handler.onConnect((reason) => {
+      this.aborted = true
+      if (this.abort) {
+        this.abort(reason)
+      } else {
+        this.reason = reason
+      }
+    })
+  }
+
+  onConnect(abort) {
+    if (this.aborted) {
+      abort(this.reason)
+    } else {
+      this.abort = abort
+    }
+  }
+
+  onBodySent(chunk) {
+    return this.handler.onBodySent(chunk)
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+    if (statusCode < 400) {
+      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+    }
+
+    const err = createError(statusCode, { headers: parseHeaders(rawHeaders) })
+
+    const retryAfter = retryAfterFn(err, this.count++, this.opts)
+    if (retryAfter == null) {
+      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+    }
+    assert(Number.isFinite(retryAfter), 'invalid retryAfter')
+
+    this.retryAfter = retryAfter
+
+    this.abort(err)
+
+    return false
+  }
+
+  onData(chunk) {
+    return this.handler.onData(chunk)
+  }
+
+  onComplete(rawTrailers) {
+    return this.handler.onComplete(rawTrailers)
+  }
+
+  onError(err) {
+    if (this.timeout) {
+      clearTimeout(this.timeout)
+      this.timeout = null
+    }
+
+    if (this.retryAfter == null || this.aborted || isDisturbed(this.opts.body)) {
+      return this.handler.onError(err)
+    }
+
+    this.opts.logger?.debug('retrying response status', { retryAfter: this.retryAfter })
+
+    this.timeout = setTimeout(() => {
+      this.timeout = null
+      try {
+        this.dispatch(this.opts, this)
+      } catch (err) {
+        this.handler.onError(err)
+      }
+    }, this.retryAfter)
+    this.retryAfter = null
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) =>
+  opts.idempotent && opts.retry
+    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
+    : dispatch(opts, handler)

package/undici/interceptor/signal.js

@@ -0,0 +1,47 @@
+class Handler {
+  constructor(opts, signal, { handler }) {
+    this.handler = handler
+    this.signal = signal
+    this.abort = null
+  }
+
+  onConnect(abort) {
+    this.abort = () => {
+      abort(this.signal.reason)
+    }
+    this.signal.addEventListener('abort', this.abort)
+
+    if (this.signal.aborted) {
+      abort(this.signal.reason)
+    } else {
+      this.handler.onConnect(abort)
+    }
+  }
+
+  onBodySent(chunk) {
+    return this.handler.onBodySent(chunk)
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+  }
+
+  onData(chunk) {
+    return this.handler.onData(chunk)
+  }
+
+  onComplete(rawTrailers) {
+    this.signal.removeEventListener('abort', this.abort)
+    return this.handler.onComplete(rawTrailers)
+  }
+
+  onError(err) {
+    this.signal.removeEventListener('abort', this.abort)
+    return this.handler.onError(err)
+  }
+}
+
+module.exports =
+  (dispatch) =>
+  ({ signal, ...opts }, handler) =>
+    signal ? dispatch(opts, new Handler(opts, signal, { handler })) : dispatch(opts, handler)

package/undici/utils.js

@@ -0,0 +1,171 @@
+function isDisturbed(body) {
+  return !(body == null || typeof body === 'string' || Buffer.isBuffer(body))
+}
+
+function parseContentRange(range) {
+  if (typeof range !== 'string') {
+    return null
+  }
+
+  const m = range.match(/^bytes (\d+)-(\d+)?\/(\d+|\*)$/)
+  if (!m) {
+    return null
+  }
+
+  const start = m[1] == null ? null : Number(m[1])
+  if (!Number.isFinite(start)) {
+    return null
+  }
+
+  const end = m[2] == null ? null : Number(m[2])
+  if (end !== null && !Number.isFinite(end)) {
+    return null
+  }
+
+  const size = m[2] === '*' ? null : Number(m[2])
+  if (size !== null && !Number.isFinite(size)) {
+    return null
+  }
+
+  return { start, end: end + 1, size }
+}
+
+function findHeader(rawHeaders, name) {
+  const len = name.length
+
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    const key = rawHeaders[i + 0]
+    if (key.length === len && key.toString().toLowerCase() === name) {
+      return rawHeaders[i + 1].toString()
+    }
+  }
+  return null
+}
+
+function retryAfter(err, retryCount, opts) {
+  if (opts.retry === null || opts.retry === false) {
+    return null
+  }
+
+  if (typeof opts.retry === 'function') {
+    const ret = opts.retry(err, retryCount)
+    if (ret != null) {
+      return ret
+    }
+  }
+
+  const retryMax = opts.retry?.count ?? opts.maxRetries ?? 8
+
+  if (retryCount > retryMax) {
+    return null
+  }
+
+  if (err.statusCode && [420, 429, 502, 503, 504].includes(err.statusCode)) {
+    const retryAfter = err.headers['retry-after'] ? err.headers['retry-after'] * 1e3 : null
+    return retryAfter ?? Math.min(10e3, retryCount * 1e3)
+  }
+
+  if (
+    err.code &&
+    [
+      'ECONNRESET',
+      'ECONNREFUSED',
+      'ENOTFOUND',
+      'ENETDOWN',
+      'ENETUNREACH',
+      'EHOSTDOWN',
+      'EHOSTUNREACH',
+      'EPIPE',
+    ].includes(err.code)
+  ) {
+    return Math.min(10e3, retryCount * 1e3)
+  }
+
+  if (err.message && ['other side closed'].includes(err.message)) {
+    return Math.min(10e3, retryCount * 1e3)
+  }
+
+  return null
+}
+
+function parseURL(url) {
+  if (typeof url === 'string') {
+    url = new URL(url)
+
+    if (!/^https?:/.test(url.origin || url.protocol)) {
+      throw new Error('Invalid URL protocol: the URL must start with `http:` or `https:`.')
+    }
+
+    return url
+  }
+
+  if (!url || typeof url !== 'object') {
+    throw new Error('Invalid URL: The URL argument must be a non-null object.')
+  }
+
+  if (url.port != null && url.port !== '' && !Number.isFinite(parseInt(url.port))) {
+    throw new Error(
+      'Invalid URL: port must be a valid integer or a string representation of an integer.',
+    )
+  }
+
+  if (url.path != null && typeof url.path !== 'string') {
+    throw new Error('Invalid URL path: the path must be a string or null/undefined.')
+  }
+
+  if (url.pathname != null && typeof url.pathname !== 'string') {
+    throw new Error('Invalid URL pathname: the pathname must be a string or null/undefined.')
+  }
+
+  if (url.hostname != null && typeof url.hostname !== 'string') {
+    throw new Error('Invalid URL hostname: the hostname must be a string or null/undefined.')
+  }
+
+  if (url.origin != null && typeof url.origin !== 'string') {
+    throw new Error('Invalid URL origin: the origin must be a string or null/undefined.')
+  }
+
+  if (!/^https?:/.test(url.origin || url.protocol)) {
+    throw new Error('Invalid URL protocol: the URL must start with `http:` or `https:`.')
+  }
+
+  if (!(url instanceof URL)) {
+    const port = url.port != null ? url.port : url.protocol === 'https:' ? 443 : 80
+    let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`
+    let path = url.path != null ? url.path : `${url.pathname || ''}${url.search || ''}`
+
+    if (origin.endsWith('/')) {
+      origin = origin.substring(0, origin.length - 1)
+    }
+
+    if (path && !path.startsWith('/')) {
+      path = `/${path}`
+    }
+    // new URL(path, origin) is unsafe when `path` contains an absolute URL
+    // From https://developer.mozilla.org/en-US/docs/Web/API/URL/URL:
+    // If first parameter is a relative URL, second param is required, and will be used as the base URL.
+    // If first parameter is an absolute URL, a given second param will be ignored.
+    url = new URL(origin + path)
+  }
+
+  return url
+}
+
+function parseOrigin(url) {
+  url = module.exports.parseURL(url)
+
+  if (url.pathname !== '/' || url.search || url.hash) {
+    throw new Error('invalid url')
+  }
+
+  return url
+}
+
+module.exports = {
+  isDisturbed,
+  parseContentRange,
+  findHeader,
+  retryAfter,
+  parseURL,
+  parseOrigin,
+}

package/undici.js

@@ -1,160 +0,0 @@
-const assert = require('assert')
-const { errorMonitor } = require('node:events')
-const tp = require('timers/promises')
-const xuid = require('xuid')
-const { isReadableNodeStream, readableStreamLength } = require('./stream')
-const undici = require('undici')
-const stream = require('stream')
-const omitEmpty = require('omit-empty')
-
-module.exports.request = async function request(
-  url,
-  {
-    logger,
-    id = xuid(),
-    retry,
-    maxRedirections: _maxRedirections,
-    idempotent,
-    redirect,
-    dispatcher,
-    signal,
-    headersTimeout,
-    bodyTimeout,
-    reset = false,
-    body,
-    method = body ? 'POST' : 'GET',
-    userAgent,
-    headers,
-    dump = method === 'HEAD',
-  }
-) {
-  if (retry === false) {
-    retry = { count: 0 }
-  } else if (typeof retry === 'number') {
-    retry = { count: retry }
-  }
-
-  if (redirect === false) {
-    redirect = { count: 0 }
-  } else if (typeof redirect === 'number') {
-    redirect = { count: redirect }
-  }
-
-  const { count: maxRedirections = _maxRedirections ?? 3 } = redirect ?? {}
-  const {
-    count: maxRetries = 8,
-    method: retryMethod = ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE', 'PATCH'],
-    status: retryStatus = [420, 429, 502, 503, 504],
-    code: retryCode = [
-      'ECONNRESET',
-      'ECONNREFUSED',
-      'ENOTFOUND',
-      'ENETDOWN',
-      'ENETUNREACH',
-      'EHOSTDOWN',
-      'EHOSTUNREACH',
-      'EPIPE',
-    ],
-    message: retryMessage = ['other side closed'],
-  } = retry ?? {}
-
-  if (readableStreamLength(body) === 0) {
-    body.on('error', () => {})
-    body = null
-  }
-
-  const ureq = {
-    url,
-    method,
-    body,
-    headers: omitEmpty({
-      'request-id': id,
-      'user-agent': userAgent,
-      ...headers,
-    }),
-  }
-
-  let upstreamLogger = logger?.child({ ureq })
-
-  upstreamLogger?.debug('upstream request started')
-
-  try {
-    /* eslint-disable no-unreachable-loop */
-    for (let retryCount = 0; true; retryCount++) {
-      let ures
-      try {
-        ures = await undici.request(url, {
-          method,
-          reset,
-          body,
-          headers,
-          signal,
-          dispatcher,
-          maxRedirections,
-          throwOnError: true,
-          headersTimeout,
-          bodyTimeout,
-        })
-
-        upstreamLogger = upstreamLogger?.child({ ures })
-
-        upstreamLogger?.debug('upstream request response')
-
-        if (ures.statusCode >= 300 && ures.statusCode < 400) {
-          throw new Error('maxRedirections exceeded')
-        }
-
-        assert(ures.statusCode >= 200 && ures.statusCode < 300)
-
-        if (dump) {
-          await ures.body.dump()
-        }
-
-        ures.body.on(errorMonitor, (err) => {
-          upstreamLogger?.debug({ err }, 'upstream request response body failed')
-        })
-
-        // TODO (fix): Wrap response to handle error that can continue with range request...
-
-        return ures
-      } catch (err) {
-        await ures?.body.dump()
-
-        if (retryCount >= maxRetries) {
-          throw err
-        }
-
-        if (
-          body != null &&
-          typeof body !== 'string' &&
-          !Buffer.isBuffer(body) &&
-          (!isReadableNodeStream(body) || stream.isDisturbed(body))
-        ) {
-          throw err
-        }
-
-        if (!retryMethod.includes(method) && !idempotent) {
-          throw err
-        }
-
-        if (
-          !retryCode.includes(err.code) &&
-          !retryMessage.includes(err.message) &&
-          !retryStatus.includes(err.statusCode)
-        ) {
-          throw err
-        }
-
-        const delay =
-          parseInt(err.headers?.['Retry-After']) * 1e3 || Math.min(10e3, retryCount * 1e3 + 1e3)
-
-        upstreamLogger?.warn({ err, retryCount, delay }, 'upstream request retrying')
-
-        await tp.setTimeout(delay, undefined, { signal })
-      }
-    }
-  } catch (err) {
-    upstreamLogger?.error({ err }, 'upstream request failed')
-    throw err
-  }
-}