@nxtedition/nxt-undici 1.0.0

package/lib/interceptor/log.js

@@ -0,0 +1,79 @@
+const { parseHeaders } = require('../utils')
+const xuid = require('xuid')
+const { performance } = require('perf_hooks')
+
+class Handler {
+  constructor(opts, { handler }) {
+    this.handler = handler
+    this.opts = opts.id ? opts : { ...opts, id: xuid() }
+    this.abort = null
+    this.aborted = false
+    this.logger = opts.logger.child({ ureq: { id: opts.id } })
+    this.pos = 0
+    this.startTime = 0
+  }
+
+  onConnect(abort) {
+    this.abort = abort
+    this.startTime = performance.now()
+    this.logger.debug({ ureq: this.opts }, 'upstream request started')
+    this.handler.onConnect((reason) => {
+      this.aborted = true
+      this.abort(reason)
+    })
+  }
+
+  onUpgrade(statusCode, rawHeaders, socket) {
+    this.logger.debug({ ureq: this.opts }, 'upstream request upgraded')
+    socket.on('close', () => {
+      this.logger.debug({ ureq: this.opts }, 'upstream request socket closed')
+    })
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  }
+
+  onBodySent(chunk) {
+    return this.handler.onBodySent(chunk)
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+    this.logger.debug(
+      {
+        ures: { statusCode, headers: parseHeaders(rawHeaders) },
+        elapsedTime: this.startTime - performance.now(),
+      },
+      'upstream request response',
+    )
+    return this.handler.onHeaders(statusCode, rawHeaders, resume, statusMessage)
+  }
+
+  onData(chunk) {
+    this.pos += chunk.length
+    return this.handler.onData(chunk)
+  }
+
+  onComplete(rawTrailers) {
+    this.logger.debug(
+      { bytesRead: this.pos, elapsedTime: this.startTime - performance.now() },
+      'upstream request completed',
+    )
+    return this.handler.onComplete(rawTrailers)
+  }
+
+  onError(err) {
+    if (this.aborted) {
+      this.logger.debug(
+        { bytesRead: this.pos, elapsedTime: this.startTime - performance.now(), err },
+        'upstream request aborted',
+      )
+    } else {
+      this.logger.error(
+        { bytesRead: this.pos, elapsedTime: this.startTime - performance.now(), err },
+        'upstream request failed',
+      )
+    }
+    return this.handler.onError(err)
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) =>
+  opts.logger ? dispatch(opts, new Handler(opts, { handler })) : dispatch(opts, handler)

package/lib/interceptor/proxy.js

@@ -0,0 +1,200 @@
+const createError = require('http-errors')
+const net = require('net')
+
+class Handler {
+  constructor(opts, { handler }) {
+    this.handler = handler
+    this.opts = opts
+  }
+
+  onConnect(abort) {
+    return this.handler.onConnect(abort)
+  }
+
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade(
+      statusCode,
+      reduceHeaders(
+        {
+          headers: rawHeaders,
+          httpVersion: this.opts.proxy.httpVersion ?? this.opts.proxy.req?.httpVersion,
+          socket: null,
+          proxyName: this.opts.proxy.name,
+        },
+        (acc, key, val) => {
+          acc.push(key, val)
+          return acc
+        },
+        [],
+      ),
+      socket,
+    )
+  }
+
+  onBodySent(chunk) {
+    return this.handler.onBodySent(chunk)
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+    return this.handler.onHeaders(
+      statusCode,
+      reduceHeaders(
+        {
+          headers: rawHeaders,
+          httpVersion: this.opts.proxy.httpVersion ?? this.opts.proxy.req?.httpVersion,
+          socket: null,
+          proxyName: this.opts.proxy.name,
+        },
+        (acc, key, val) => {
+          acc.push(key, val)
+          return acc
+        },
+        [],
+      ),
+      resume,
+      statusMessage,
+    )
+  }
+
+  onData(chunk) {
+    return this.handler.onData(chunk)
+  }
+
+  onComplete(rawTrailers) {
+    return this.handler.onComplete(rawTrailers)
+  }
+
+  onError(err) {
+    return this.handler.onError(err)
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) => {
+  if (!opts.proxy) {
+    return dispatch(opts, handler)
+  }
+
+  const headers = reduceHeaders(
+    {
+      headers: opts.headers ?? {},
+      httpVersion: opts.proxy.httpVersion ?? opts.proxy.req?.httpVersion,
+      socket: opts.proxy.socket ?? opts.proxy.req?.socket,
+      proxyName: opts.proxy.name,
+    },
+    (obj, key, val) => {
+      obj[key] = val
+      return obj
+    },
+    {},
+  )
+
+  opts = { ...opts, headers }
+
+  return dispatch(opts, new Handler(opts, { handler }))
+}
+
+// This expression matches hop-by-hop headers.
+// These headers are meaningful only for a single transport-level connection,
+// and must not be retransmitted by proxies or cached.
+const HOP_EXPR =
+  /^(te|host|upgrade|trailers|connection|keep-alive|http2-settings|transfer-encoding|proxy-connection|proxy-authenticate|proxy-authorization)$/i
+
+function forEachHeader(headers, fn) {
+  if (Array.isArray(headers)) {
+    for (let n = 0; n < headers.length; n += 2) {
+      fn(headers[n + 0].toString(), headers[n + 1].toString())
+    }
+  } else {
+    for (const [key, val] of Object.entries(headers)) {
+      fn(key, val)
+    }
+  }
+}
+
+// Removes hop-by-hop and pseudo headers.
+// Updates via and forwarded headers.
+// Only hop-by-hop headers may be set using the Connection general header.
+function reduceHeaders({ headers, proxyName, httpVersion, socket }, fn, acc) {
+  let via = ''
+  let forwarded = ''
+  let host = ''
+  let authority = ''
+  let connection = ''
+
+  forEachHeader(headers, (key, val) => {
+    const len = key.length
+    if (len === 3 && !via && key.toLowerCase() === 'via') {
+      via = val
+    } else if (len === 4 && !host && key.toLowerCase() === 'host') {
+      host = val
+    } else if (len === 9 && !forwarded && key.toLowerCase() === 'forwarded') {
+      forwarded = val
+    } else if (len === 10 && !connection && key.toLowerCase() === 'connection') {
+      connection = val
+    } else if (len === 10 && !authority && key.toLowerCase() === ':authority') {
+      authority = val
+    }
+  })
+
+  let remove = []
+  if (connection && !HOP_EXPR.test(connection)) {
+    remove = connection.split(/,\s*/)
+  }
+
+  forEachHeader(headers, (key, val) => {
+    if (key.charAt(0) !== ':' && !remove.includes(key) && !HOP_EXPR.test(key)) {
+      acc = fn(acc, key, val)
+    }
+  })
+
+  if (socket) {
+    const forwardedHost = authority || host
+    acc = fn(
+      acc,
+      'forwarded',
+      (forwarded ? forwarded + ', ' : '') +
+        [
+          socket.localAddress && `by=${printIp(socket.localAddress, socket.localPort)}`,
+          socket.remoteAddress && `for=${printIp(socket.remoteAddress, socket.remotePort)}`,
+          `proto=${socket.encrypted ? 'https' : 'http'}`,
+          forwardedHost && `host="${forwardedHost}"`,
+        ].join(';'),
+    )
+  } else if (forwarded) {
+    // The forwarded header should not be included in response.
+    throw new createError.BadGateway()
+  }
+
+  if (proxyName) {
+    if (via) {
+      if (via.split(',').some((name) => name.endsWith(proxyName))) {
+        throw new createError.LoopDetected()
+      }
+      via += ', '
+    } else {
+      via = ''
+    }
+    via += `${httpVersion ?? 'HTTP/1.1'} ${proxyName}`
+  }
+
+  if (via) {
+    acc = fn(acc, 'via', via)
+  }
+
+  return acc
+}
+
+function printIp(address, port) {
+  const isIPv6 = net.isIPv6(address)
+  let str = `${address}`
+  if (isIPv6) {
+    str = `[${str}]`
+  }
+  if (port) {
+    str = `${str}:${port}`
+  }
+  if (isIPv6 || port) {
+    str = `"${str}"`
+  }
+  return str
+}

package/lib/interceptor/redirect.js

@@ -0,0 +1,184 @@
+const assert = require('assert')
+const { findHeader, isDisturbed, parseURL } = require('../utils')
+
+const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
+
+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.location = 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
+    }
+  }
+
+  onUpgrade(statusCode, headers, socket) {
+    this.handler.onUpgrade(statusCode, headers, socket)
+  }
+
+  onError(error) {
+    this.handler.onError(error)
+  }
+
+  onHeaders(statusCode, headers, resume, statusText) {
+    if (redirectableStatusCodes.indexOf(statusCode) === -1) {
+      return this.handler.onHeaders(statusCode, headers, resume, statusText)
+    }
+
+    if (isDisturbed(this.opts.body)) {
+      throw new Error(`Disturbed request cannot be redirected.`)
+    }
+
+    this.location = findHeader(headers, 'location')
+
+    if (!this.location) {
+      throw new Error(`Missing redirection location.`)
+    }
+
+    this.count += 1
+
+    if (typeof this.opts.follow === 'function') {
+      if (!this.opts.follow(this.location, this.count)) {
+        return this.handler.onHeaders(statusCode, headers, resume, statusText)
+      }
+    } else {
+      const maxCount = this.opts.follow.count ?? 0
+
+      if (this.count >= maxCount) {
+        throw new Error(`Max redirections reached: ${maxCount}.`)
+      }
+    }
+
+    const { origin, pathname, search } = parseURL(
+      new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)),
+    )
+    const path = search ? `${pathname}${search}` : pathname
+
+    // Remove headers referring to the original URL.
+    // By default it is Host only, unless it's a 303 (see below), which removes also all Content-* headers.
+    // https://tools.ietf.org/html/rfc7231#section-6.4
+    this.opts = {
+      ...this.opts,
+      headers: cleanRequestHeaders(
+        this.opts.headers,
+        statusCode === 303,
+        this.opts.origin !== origin,
+      ),
+      path,
+      origin,
+      query: null,
+    }
+
+    // https://tools.ietf.org/html/rfc7231#section-6.4.4
+    // In case of HTTP 303, always replace method to be either HEAD or GET
+    if (statusCode === 303 && this.opts.method !== 'HEAD') {
+      this.opts = { ...this.opts, method: 'GET', body: null }
+    }
+  }
+
+  onData(chunk) {
+    if (this.location) {
+      /*
+        https://tools.ietf.org/html/rfc7231#section-6.4
+
+        TLDR: undici always ignores 3xx response bodies.
+
+        Redirection is used to serve the requested resource from another URL, so it is assumes that
+        no body is generated (and thus can be ignored). Even though generating a body is not prohibited.
+
+        For status 301, 302, 303, 307 and 308 (the latter from RFC 7238), the specs mention that the body usually
+        (which means it's optional and not mandated) contain just an hyperlink to the value of
+        the Location response header, so the body can be ignored safely.
+
+        For status 300, which is "Multiple Choices", the spec mentions both generating a Location
+        response header AND a response body with the other possible location to follow.
+        Since the spec explicitily chooses not to specify a format for such body and leave it to
+        servers and browsers implementors, we ignore the body as there is no specified way to eventually parse it.
+      */
+    } else {
+      return this.handler.onData(chunk)
+    }
+  }
+
+  onComplete(trailers) {
+    if (this.location) {
+      /*
+        https://tools.ietf.org/html/rfc7231#section-6.4
+
+        TLDR: undici always ignores 3xx response trailers as they are not expected in case of redirections
+        and neither are useful if present.
+
+        See comment on onData method above for more detailed informations.
+      */
+
+      this.location = null
+
+      this.dispatch(this.opts, this)
+    } else {
+      this.handler.onComplete(trailers)
+    }
+  }
+
+  onBodySent(chunk) {
+    if (this.handler.onBodySent) {
+      this.handler.onBodySent(chunk)
+    }
+  }
+}
+
+// https://tools.ietf.org/html/rfc7231#section-6.4.4
+function shouldRemoveHeader(header, removeContent, unknownOrigin) {
+  return (
+    (header.length === 4 && header.toString().toLowerCase() === 'host') ||
+    (removeContent && header.toString().toLowerCase().indexOf('content-') === 0) ||
+    (unknownOrigin &&
+      header.length === 13 &&
+      header.toString().toLowerCase() === 'authorization') ||
+    (unknownOrigin && header.length === 6 && header.toString().toLowerCase() === 'cookie')
+  )
+}
+
+// https://tools.ietf.org/html/rfc7231#section-6.4
+function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
+  const ret = []
+  if (Array.isArray(headers)) {
+    for (let i = 0; i < headers.length; i += 2) {
+      if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
+        ret.push(headers[i], headers[i + 1])
+      }
+    }
+  } else if (headers && typeof headers === 'object') {
+    for (const key of Object.keys(headers)) {
+      if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
+        ret.push(key, headers[key])
+      }
+    }
+  } else {
+    assert(headers == null, 'headers must be an object or an array')
+  }
+  return ret
+}
+
+module.exports = (dispatch) => (opts, handler) =>
+  opts.follow ? dispatch(opts, new Handler(opts, { handler, dispatch })) : dispatch(opts, handler)

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

@@ -0,0 +1,158 @@
+const assert = require('node:assert')
+const { parseContentRange, isDisturbed, findHeader, retry: retryFn } = 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
+    }
+  }
+
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  }
+
+  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 retryPromise = retryFn(err, this.count++, this.opts)
+    if (retryPromise == null) {
+      return this.handler.onError(err)
+    }
+
+    retryPromise
+      .then(() => {
+        this.timeout = null
+        try {
+          this.dispatch(this.opts, this)
+        } catch (err2) {
+          this.handler.onError(err)
+        }
+      })
+      .catch((err) => {
+        this.handler.onError(err)
+      })
+
+    this.error = err
+    this.opts = {
+      ...this.opts,
+      headers: {
+        ...this.opts.headers,
+        'if-match': this.etag,
+        range: `bytes=${this.pos}-${this.end ?? ''}`,
+      },
+    }
+
+    this.opts.loggerdebug('retrying response body')
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) => {
+  return opts.idempotent && opts.retry && opts.method === 'GET' && !opts.upgrade
+    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
+    : dispatch(opts, handler)
+}

package/lib/interceptor/response-retry.js

@@ -0,0 +1,89 @@
+const { isDisturbed, retry: retryFn } = 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
+    }
+  }
+
+  onUpgrade(statusCode, rawHeaders, socket) {
+    return this.handler.onUpgrade(statusCode, rawHeaders, socket)
+  }
+
+  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 retryPromise = retryFn(err, this.count++, this.opts)
+    if (retryPromise == null) {
+      return this.handler.onError(err)
+    }
+
+    retryPromise
+      .then(() => {
+        this.timeout = null
+        try {
+          this.dispatch(this.opts, this)
+        } catch (err2) {
+          this.handler.onError(err)
+        }
+      })
+      .catch((err) => {
+        this.handler.onError(err)
+      })
+
+    this.opts.loggerdebug('retrying response')
+  }
+}
+
+module.exports = (dispatch) => (opts, handler) =>
+  opts.idempotent && opts.retry
+    ? dispatch(opts, new Handler(opts, { handler, dispatch }))
+    : dispatch(opts, handler)