@nxtedition/nxt-undici 2.0.20 → 2.0.22

package/lib/errors.js

@@ -0,0 +1,214 @@
+export class UndiciError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'UndiciError'
+    this.code = 'UND_ERR'
+  }
+}
+
+export class ConnectTimeoutError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, ConnectTimeoutError)
+    this.name = 'ConnectTimeoutError'
+    this.message = message || 'Connect Timeout Error'
+    this.code = 'UND_ERR_CONNECT_TIMEOUT'
+  }
+}
+
+export class HeadersTimeoutError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, HeadersTimeoutError)
+    this.name = 'HeadersTimeoutError'
+    this.message = message || 'Headers Timeout Error'
+    this.code = 'UND_ERR_HEADERS_TIMEOUT'
+  }
+}
+
+export class HeadersOverflowError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, HeadersOverflowError)
+    this.name = 'HeadersOverflowError'
+    this.message = message || 'Headers Overflow Error'
+    this.code = 'UND_ERR_HEADERS_OVERFLOW'
+  }
+}
+
+export class BodyTimeoutError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, BodyTimeoutError)
+    this.name = 'BodyTimeoutError'
+    this.message = message || 'Body Timeout Error'
+    this.code = 'UND_ERR_BODY_TIMEOUT'
+  }
+}
+
+export class ResponseStatusCodeError extends UndiciError {
+  constructor(message, statusCode, headers, body) {
+    super(message)
+    Error.captureStackTrace(this, ResponseStatusCodeError)
+    this.name = 'ResponseStatusCodeError'
+    this.message = message || 'Response Status Code Error'
+    this.code = 'UND_ERR_RESPONSE_STATUS_CODE'
+    this.body = body
+    this.status = statusCode
+    this.statusCode = statusCode
+    this.headers = headers
+  }
+}
+
+export class InvalidArgumentError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, InvalidArgumentError)
+    this.name = 'InvalidArgumentError'
+    this.message = message || 'Invalid Argument Error'
+    this.code = 'UND_ERR_INVALID_ARG'
+  }
+}
+
+export class InvalidReturnValueError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, InvalidReturnValueError)
+    this.name = 'InvalidReturnValueError'
+    this.message = message || 'Invalid Return Value Error'
+    this.code = 'UND_ERR_INVALID_RETURN_VALUE'
+  }
+}
+
+export class AbortError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, AbortError)
+    this.name = 'AbortError'
+    this.message = message || 'The operation was aborted'
+  }
+}
+
+export class RequestAbortedError extends AbortError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, RequestAbortedError)
+    this.name = 'AbortError'
+    this.message = message || 'Request aborted'
+    this.code = 'UND_ERR_ABORTED'
+  }
+}
+
+export class InformationalError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, InformationalError)
+    this.name = 'InformationalError'
+    this.message = message || 'Request information'
+    this.code = 'UND_ERR_INFO'
+  }
+}
+
+export class RequestContentLengthMismatchError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, RequestContentLengthMismatchError)
+    this.name = 'RequestContentLengthMismatchError'
+    this.message = message || 'Request body length does not match content-length header'
+    this.code = 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'
+  }
+}
+
+export class ResponseContentLengthMismatchError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, ResponseContentLengthMismatchError)
+    this.name = 'ResponseContentLengthMismatchError'
+    this.message = message || 'Response body length does not match content-length header'
+    this.code = 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'
+  }
+}
+
+export class ClientDestroyedError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, ClientDestroyedError)
+    this.name = 'ClientDestroyedError'
+    this.message = message || 'The client is destroyed'
+    this.code = 'UND_ERR_DESTROYED'
+  }
+}
+
+export class ClientClosedError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, ClientClosedError)
+    this.name = 'ClientClosedError'
+    this.message = message || 'The client is closed'
+    this.code = 'UND_ERR_CLOSED'
+  }
+}
+
+export class SocketError extends UndiciError {
+  constructor(message, socket) {
+    super(message)
+    Error.captureStackTrace(this, SocketError)
+    this.name = 'SocketError'
+    this.message = message || 'Socket error'
+    this.code = 'UND_ERR_SOCKET'
+    this.socket = socket
+  }
+}
+
+export class NotSupportedError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, NotSupportedError)
+    this.name = 'NotSupportedError'
+    this.message = message || 'Not supported error'
+    this.code = 'UND_ERR_NOT_SUPPORTED'
+  }
+}
+
+export class BalancedPoolMissingUpstreamError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, NotSupportedError)
+    this.name = 'MissingUpstreamError'
+    this.message = message || 'No upstream has been added to the BalancedPool'
+    this.code = 'UND_ERR_BPL_MISSING_UPSTREAM'
+  }
+}
+
+export class HTTPParserError extends Error {
+  constructor(message, code, data) {
+    super(message)
+    Error.captureStackTrace(this, HTTPParserError)
+    this.name = 'HTTPParserError'
+    this.code = code ? `HPE_${code}` : undefined
+    this.data = data ? data.toString() : undefined
+  }
+}
+
+export class ResponseExceededMaxSizeError extends UndiciError {
+  constructor(message) {
+    super(message)
+    Error.captureStackTrace(this, ResponseExceededMaxSizeError)
+    this.name = 'ResponseExceededMaxSizeError'
+    this.message = message || 'Response content exceeded max size'
+    this.code = 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
+  }
+}
+
+export class RequestRetryError extends UndiciError {
+  constructor(message, code, { headers, data }) {
+    super(message)
+    Error.captureStackTrace(this, RequestRetryError)
+    this.name = 'RequestRetryError'
+    this.message = message || 'Request retry error'
+    this.code = 'UND_ERR_REQ_RETRY'
+    this.statusCode = code
+    this.data = data
+    this.headers = headers
+  }
+}

package/lib/index.js

@@ -1,8 +1,8 @@
 import assert from 'node:assert'
-import stream from 'node:stream'
 import createError from 'http-errors'
 import undici from 'undici'
 import { findHeader, parseHeaders, AbortError, isStream } from './utils.js'
+import { BodyReadable as Readable } from './readable.js'
 import CacheableLookup from 'cacheable-lookup'
 
 const dispatcherCache = new WeakMap()
@@ -20,125 +20,6 @@ function genReqId() {
   return `req-${nextReqId.toString(36)}`
 }
 
-const kAbort = Symbol('abort')
-const kStatusCode = Symbol('statusCode')
-const kStatusMessage = Symbol('statusMessage')
-const kHeaders = Symbol('headers')
-const kSize = Symbol('size')
-const kHandler = Symbol('handler')
-
-let ABORT_ERROR
-
-class Readable extends stream.Readable {
-  constructor(handler, { statusCode, statusMessage, headers, size, abort, highWaterMark, resume }) {
-    super({ highWaterMark })
-
-    this[kHandler] = handler
-    this[kStatusCode] = statusCode
-    this[kStatusMessage] = statusMessage
-    this[kHeaders] = headers
-    this[kSize] = size
-    this[kAbort] = abort
-
-    this._read = resume
-  }
-
-  get statusCode() {
-    return this[kStatusCode]
-  }
-
-  get statusMessage() {
-    return this[kStatusMessage]
-  }
-
-  get headers() {
-    return this[kHeaders]
-  }
-
-  get size() {
-    return this[kSize]
-  }
-
-  get body() {
-    return this
-  }
-
-  _destroy(err, callback) {
-    if (err == null && !this.readableEnded) {
-      ABORT_ERROR ??= new AbortError()
-      err = ABORT_ERROR
-    }
-
-    if (err) {
-      this[kAbort](err)
-    }
-
-    if (this[kHandler].signal) {
-      this[kHandler].signal.removeEventListener('abort', this[kHandler].onAbort)
-      this[kHandler].signal = null
-    }
-
-    // Workaround: https://github.com/nodejs/undici/pull/2497
-    queueMicrotask(() => {
-      callback(err)
-    })
-  }
-
-  async text() {
-    const dec = new TextDecoder()
-    let str = ''
-
-    for await (const chunk of this) {
-      if (typeof chunk === 'string') {
-        str += chunk
-      } else {
-        str += dec.decode(chunk, { stream: true })
-      }
-    }
-
-    // Flush the streaming TextDecoder so that any pending
-    // incomplete multibyte characters are handled.
-    str += dec.decode(undefined, { stream: false })
-    return str
-  }
-
-  async json() {
-    return JSON.parse(await this.text())
-  }
-
-  async arrayBuffer() {
-    return (await this.buffer()).buffer
-  }
-
-  async buffer() {
-    const buffers = []
-    for await (const chunk of this) {
-      buffers.push(chunk)
-    }
-    return Buffer.concat(buffers)
-  }
-
-  dump() {
-    return new Promise((resolve) => {
-      const rState = this._readableState
-      if (rState.closeEmitted) {
-        resolve(null)
-      } else {
-        let n = 0
-        this.on('close', () => resolve(null))
-          .on('error', () => {})
-          .on('data', (chunk) => {
-            n += chunk.length
-            if (n > 128 * 1024) {
-              this.destroy()
-            }
-          })
-          .resume()
-      }
-    })
-  }
-}
-
 const dispatchers = {
   responseError: (await import('./interceptor/response-error.js')).default,
   requestBodyFactory: (await import('./interceptor/request-body-factory.js')).default,
@@ -319,7 +200,8 @@ export async function request(url, opts) {
         ) {
           assert(statusCode >= 200)
 
-          const contentLength = findHeader(rawHeaders, 'content-length')
+          const contentLength = findHeader(headers, 'content-length')
+          const contentType = findHeader(headers, 'content-type')
 
           this.body = new Readable(this, {
             resume,
@@ -327,6 +209,7 @@ export async function request(url, opts) {
             highWaterMark: this.highWaterMark,
             statusCode,
             statusMessage,
+            contentType,
             headers,
             size: Number.isFinite(contentLength) ? contentLength : null,
           })

package/lib/readable.js

@@ -0,0 +1,338 @@
+import assert from 'node:assert'
+import { Readable, isDisturbed } from 'node:stream'
+import {
+  RequestAbortedError,
+  NotSupportedError,
+  InvalidArgumentError,
+  AbortError,
+} from './errors.js'
+
+let Blob
+
+const kConsume = Symbol('kConsume')
+const kReading = Symbol('kReading')
+const kBody = Symbol('kBody')
+const kAbort = Symbol('abort')
+const kContentType = Symbol('kContentType')
+
+const kStatusCode = Symbol('kStatusCode')
+const kStatusMessage = Symbol('kStatusMessage')
+const kHeaders = Symbol('kHeaders')
+const kSize = Symbol('kSize')
+const kHandler = Symbol('kHandler')
+
+const noop = () => {}
+
+let ABORT_ERROR
+
+export class BodyReadable extends Readable {
+  constructor(
+    handler,
+    { contentType = '', statusCode, statusMessage, headers, size, abort, highWaterMark, resume },
+  ) {
+    super({
+      autoDestroy: true,
+      read: resume,
+      highWaterMark,
+    })
+
+    this._readableState.dataEmitted = false
+
+    this[kHandler] = handler
+    this[kStatusCode] = statusCode
+    this[kStatusMessage] = statusMessage
+    this[kHeaders] = headers
+    this[kSize] = size
+    this[kAbort] = abort
+
+    this[kConsume] = null
+    this[kBody] = null
+    this[kContentType] = contentType
+
+    // Is stream being consumed through Readable API?
+    // This is an optimization so that we avoid checking
+    // for 'data' and 'readable' listeners in the hot path
+    // inside push().
+    this[kReading] = false
+  }
+
+  get statusCode() {
+    return this[kStatusCode]
+  }
+
+  get statusMessage() {
+    return this[kStatusMessage]
+  }
+
+  get headers() {
+    return this[kHeaders]
+  }
+
+  get size() {
+    return this[kSize]
+  }
+
+  get body() {
+    return this
+  }
+
+  _destroy(err, callback) {
+    if (!err && !this._readableState.endEmitted) {
+      err = ABORT_ERROR ??= new RequestAbortedError()
+    }
+
+    if (err) {
+      this[kAbort]()
+    }
+
+    if (this[kHandler].signal) {
+      this[kHandler].signal.removeEventListener('abort', this[kHandler].onAbort)
+      this[kHandler].signal = null
+    }
+
+    // Workaround for Node "bug". If the stream is destroyed in same
+    // tick as it is created, then a user who is waiting for a
+    // promise (i.e micro tick) for installing a 'error' listener will
+    // never get a chance and will always encounter an unhandled exception.
+    // - tick => process.nextTick(fn)
+    // - micro tick => queueMicrotask(fn)
+    queueMicrotask(() => {
+      callback(err)
+    })
+  }
+
+  on(ev, ...args) {
+    if (ev === 'data' || ev === 'readable') {
+      this[kReading] = true
+    }
+    return super.on(ev, ...args)
+  }
+
+  addListener(ev, ...args) {
+    return this.on(ev, ...args)
+  }
+
+  off(ev, ...args) {
+    const ret = super.off(ev, ...args)
+    if (ev === 'data' || ev === 'readable') {
+      this[kReading] = this.listenerCount('data') > 0 || this.listenerCount('readable') > 0
+    }
+    return ret
+  }
+
+  removeListener(ev, ...args) {
+    return this.off(ev, ...args)
+  }
+
+  push(chunk) {
+    if (this[kConsume] && chunk !== null && this.readableLength === 0) {
+      consumePush(this[kConsume], chunk)
+      return this[kReading] ? super.push(chunk) : true
+    }
+    return super.push(chunk)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-text
+  async text() {
+    return consume(this, 'text')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-json
+  async json() {
+    return consume(this, 'json')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-blob
+  async blob() {
+    return consume(this, 'blob')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+  async arrayBuffer() {
+    return consume(this, 'arrayBuffer')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-formdata
+  async formData() {
+    // TODO: Implement.
+    throw new NotSupportedError()
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-bodyused
+  get bodyUsed() {
+    return isDisturbed(this)
+  }
+
+  async dump(opts) {
+    let limit = Number.isFinite(opts?.limit) ? opts.limit : 262144
+    const signal = opts?.signal
+
+    if (signal != null && (typeof signal !== 'object' || !('aborted' in signal))) {
+      throw new InvalidArgumentError('signal must be an AbortSignal')
+    }
+
+    signal?.throwIfAborted()
+
+    if (this._readableState.closeEmitted) {
+      return null
+    }
+
+    return await new Promise((resolve, reject) => {
+      const onAbort = () => {
+        this.destroy(signal.reason ?? new AbortError())
+      }
+      signal?.addEventListener('abort', onAbort)
+
+      this.on('close', function () {
+        signal?.removeEventListener('abort', onAbort)
+        if (signal?.aborted) {
+          reject(signal.reason ?? new AbortError())
+        } else {
+          resolve(null)
+        }
+      })
+        .on('error', noop)
+        .on('data', function (chunk) {
+          limit -= chunk.length
+          if (limit <= 0) {
+            this.destroy()
+          }
+        })
+        .resume()
+    })
+  }
+}
+
+// https://streams.spec.whatwg.org/#readablestream-locked
+function isLocked(self) {
+  // Consume is an implicit lock.
+  return (self[kBody] && self[kBody].locked === true) || self[kConsume]
+}
+
+// https://fetch.spec.whatwg.org/#body-unusable
+function isUnusable(self) {
+  return isDisturbed(self) || isLocked(self)
+}
+
+async function consume(stream, type) {
+  assert(!stream[kConsume])
+
+  return new Promise((resolve, reject) => {
+    if (isUnusable(stream)) {
+      const rState = stream._readableState
+      if (rState.destroyed && rState.closeEmitted === false) {
+        stream
+          .on('error', (err) => {
+            reject(err)
+          })
+          .on('close', () => {
+            reject(new TypeError('unusable'))
+          })
+      } else {
+        reject(rState.errored ?? new TypeError('unusable'))
+      }
+    } else {
+      stream[kConsume] = {
+        type,
+        stream,
+        resolve,
+        reject,
+        length: 0,
+        body: [],
+      }
+
+      stream
+        .on('error', function (err) {
+          consumeFinish(this[kConsume], err)
+        })
+        .on('close', function () {
+          if (this[kConsume].body !== null) {
+            consumeFinish(this[kConsume], new RequestAbortedError())
+          }
+        })
+
+      queueMicrotask(() => consumeStart(stream[kConsume]))
+    }
+  })
+}
+
+function consumeStart(consume) {
+  if (consume.body === null) {
+    return
+  }
+
+  const { _readableState: state } = consume.stream
+
+  for (const chunk of state.buffer) {
+    consumePush(consume, chunk)
+  }
+
+  if (state.endEmitted) {
+    consumeEnd(this[kConsume])
+  } else {
+    consume.stream.on('end', function () {
+      consumeEnd(this[kConsume])
+    })
+  }
+
+  consume.stream.resume()
+
+  while (consume.stream.read() != null) {
+    // Loop
+  }
+}
+
+function consumeEnd(consume) {
+  const { type, body, resolve, stream, length } = consume
+
+  try {
+    if (type === 'text') {
+      resolve(Buffer.concat(body).toString().toWellFormed())
+    } else if (type === 'json') {
+      resolve(JSON.parse(Buffer.concat(body)))
+    } else if (type === 'arrayBuffer') {
+      const dst = new Uint8Array(length)
+
+      let pos = 0
+      for (const buf of body) {
+        dst.set(buf, pos)
+        pos += buf.byteLength
+      }
+
+      resolve(dst.buffer)
+    } else if (type === 'blob') {
+      if (!Blob) {
+        Blob = require('buffer').Blob
+      }
+      resolve(new Blob(body, { type: stream[kContentType] }))
+    }
+
+    consumeFinish(consume)
+  } catch (err) {
+    stream.destroy(err)
+  }
+}
+
+function consumePush(consume, chunk) {
+  consume.length += chunk.length
+  consume.body.push(chunk)
+}
+
+function consumeFinish(consume, err) {
+  if (consume.body === null) {
+    return
+  }
+
+  if (err) {
+    consume.reject(err)
+  } else {
+    consume.resolve()
+  }
+
+  consume.type = null
+  consume.stream = null
+  consume.resolve = null
+  consume.reject = null
+  consume.length = 0
+  consume.body = null
+}

package/lib/utils.js

@@ -67,15 +67,13 @@ export function findHeader(headers, name) {
     for (let i = 0; i < headers.length; i += 2) {
       const key = headers[i + 0]
       if (key.length === len && toLowerCase(key.toString()) === name) {
-        return headers[i + 1].toString()
+        return headers[i + 1]?.toString()
       }
     }
   } else if (headers != null) {
-    {
-      const val = headers[name]
-      if (val !== undefined) {
-        return val
-      }
+    const val = headers[name]
+    if (val !== undefined) {
+      return val
     }
 
     for (const key of Object.keys(headers)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/nxt-undici",
-  "version": "2.0.20",
+  "version": "2.0.22",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "main": "lib/index.js",