@nxtedition/nxt-undici 5.1.7 → 5.2.0

package/lib/interceptor/cache.js

@@ -1,134 +1,116 @@
-import { LRUCache } from 'lru-cache'
-import { parseHeaders, parseCacheControl } from '../utils.js'
+import { SqliteCacheStore } from '../cache/sqlite-cache-store.js'
+import { DecoratorHandler, parseHeaders, parseCacheControl } from '../utils.js'
 
-class CacheHandler {
-  #handler
-  #store
-  #key
+const DEFAULT_STORE = new SqliteCacheStore({ location: ':memory:' })
+
+class CacheHandler extends DecoratorHandler {
   #value
+  #opts
+  #store
 
-  constructor({ key, handler, store }) {
-    this.#key = key
-    this.#handler = handler
+  constructor(opts, { store, handler }) {
+    super(handler)
+
+    this.#opts = opts
     this.#store = store
   }
 
   onConnect(abort) {
     this.#value = null
 
-    return this.#handler.onConnect(abort)
+    super.onConnect(abort)
   }
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
     if (statusCode !== 307) {
-      return this.#handler.onHeaders(statusCode, null, resume, statusMessage, headers)
+      // Only cache redirects...
+      return super.onHeaders(statusCode, null, resume, null, headers)
     }
 
-    // TODO (fix): Support vary header.
-    const cacheControl = parseCacheControl(headers['cache-control'])
+    if (headers.vary === '*') {
+      // Not cacheble...
+      return super.onHeaders(statusCode, null, resume, null, headers)
+    }
 
+    const cacheControl = parseCacheControl(headers['cache-control'])
     const contentLength = headers['content-length'] ? Number(headers['content-length']) : Infinity
-    const maxEntrySize = this.#store.maxEntrySize ?? Infinity
+
+    if (contentLength) {
+      // We don't support caching responses with body...
+      return super.onHeaders(statusCode, null, resume, null, headers)
+    }
 
     if (
-      (!contentLength || contentLength < maxEntrySize) &&
-      cacheControl &&
-      cacheControl.public &&
-      !cacheControl.private &&
-      !cacheControl['no-store'] &&
+      !cacheControl ||
+      !cacheControl.public ||
+      cacheControl.private ||
+      cacheControl['no-store'] ||
       // TODO (fix): Support all cache control directives...
-      // !opts.headers['no-transform'] &&
-      !cacheControl['no-cache'] &&
-      !cacheControl['must-understand'] &&
-      !cacheControl['must-revalidate'] &&
-      !cacheControl['proxy-revalidate']
+      // cacheControl['no-transform'] ||
+      cacheControl['no-cache'] ||
+      cacheControl['must-understand'] ||
+      cacheControl['must-revalidate'] ||
+      cacheControl['proxy-revalidate']
     ) {
-      const maxAge = cacheControl['s-max-age'] ?? cacheControl['max-age']
-      const ttl = cacheControl.immutable ? 31556952 : Number(maxAge)
-
-      if (ttl > 0) {
-        this.#value = {
-          statusCode,
-          statusMessage,
-          headers,
-          body: [],
-          size: 256, // TODO (fix): Measure headers size...
-          ttl: ttl * 1e3,
-        }
-      }
+      // Not cacheble...
+      return super.onHeaders(statusCode, null, resume, null, headers)
     }
 
-    return this.#handler.onHeaders(statusCode, null, resume, statusMessage, headers)
-  }
-
-  onData(chunk) {
-    if (this.#value) {
-      this.#value.size += chunk.bodyLength
-
-      const maxEntrySize = this.#store.maxEntrySize ?? Infinity
-      if (this.#value.size > maxEntrySize) {
-        this.#value = null
-      } else {
-        this.#value.data.body.push(chunk)
+    const vary = {}
+    if (headers.vary) {
+      for (const key of [headers.vary]
+        .flat()
+        .flatMap((vary) => vary.split(',').map((key) => key.trim().toLowerCase()))) {
+        const val = this.#opts.headers?.[key]
+        if (!val) {
+          // Expect vary headers to be present...
+          return super.onHeaders(statusCode, null, resume, null, headers)
+        }
+        vary[key] = val
       }
+
+      // Unexpected vary header type...
+      return super.onHeaders(statusCode, null, resume, null, headers)
     }
-    return this.#handler.onData(chunk)
-  }
 
-  onComplete() {
-    if (this.#value) {
-      this.#store.set(
-        this.#key,
-        {
-          statusCode: this.#value.statusCode,
-          statusMessage: this.#value.statusMessage,
-          headers: this.#value.headers,
-          body: Buffer.concat(this.#value.body),
-        },
-        { ttl: this.#value.ttl, size: this.#value.size },
-      )
+    const ttl = cacheControl.immutable
+      ? 31556952
+      : Number(cacheControl['s-max-age'] ?? cacheControl['max-age'])
+    if (!ttl || !Number.isFinite(ttl) || ttl <= 0) {
+      return super.onHeaders(statusCode, null, resume, null, headers)
     }
-    return this.#handler.onComplete()
-  }
 
-  onError(err) {
-    this.#handler.onError(err)
-  }
-}
+    const cachedAt = Date.now()
+
+    this.#value = {
+      body: null,
+      deleteAt: cachedAt + ttl * 1e3,
+      statusCode,
+      statusMessage: '',
+      headers,
+      cacheControlDirectives: '',
+      etag: '',
+      vary,
+      cachedAt,
+      staleAt: 0,
+    }
 
-class MemoryCacheStore {
-  constructor({ maxSize = 1024 * 1024, maxEntrySize = 128 * 1024, maxTTL = 48 * 3600e3 }) {
-    this.maxSize = maxSize
-    this.maxEntrySize = maxEntrySize
-    this.maxTTL = maxTTL
-    this.cache = new LRUCache({ maxSize })
+    return super.onHeaders(statusCode, null, resume, null, headers)
   }
 
-  set(key, value, opts) {
-    this.cache.set(
-      key,
-      value,
-      opts
-        ? {
-            ttl: opts.ttl ? Math.min(opts.ttl, this.maxTTL) : undefined,
-            size: opts.size,
-          }
-        : undefined,
-    )
+  onData(chunk) {
+    this.#value = null
+    return super.onData(chunk)
   }
 
-  get(key) {
-    return this.cache.get(key)
+  onComplete() {
+    if (this.#value) {
+      this.#store.set(this.#opts, this.#value)
+    }
+    super.onComplete()
   }
 }
 
-function makeKey(opts) {
-  // NOTE: Ignores headers...
-  return `${opts.origin}:${opts.method}:${opts.path}`
-}
-
-const DEFAULT_CACHE_STORE = new MemoryCacheStore({ maxSize: 128 * 1024, maxEntrySize: 1024 })
-
 export default () => (dispatch) => (opts, handler) => {
   if (!opts.cache || opts.upgrade) {
     return dispatch(opts, handler)
@@ -154,48 +136,47 @@ export default () => (dispatch) => (opts, handler) => {
   // Dump body...
   opts.body?.on('error', () => {}).resume()
 
-  const store = opts.cache === true ? DEFAULT_CACHE_STORE : opts.cache
-
-  if (!store) {
-    throw new Error(`Cache store not provided.`)
-  }
-
-  const key = makeKey(opts)
-  const entry = store.get(key)
-
+  const store = opts.store ?? DEFAULT_STORE
+  const entry = store.get(opts)
   if (!entry) {
-    return dispatch(opts, new CacheHandler({ handler, store, key: makeKey(opts) }))
+    return dispatch(opts, new CacheHandler(opts.headers, { store, handler }))
   }
 
-  const { statusCode, statusMessage, headers, body } = entry
-
   let aborted = false
-  const abort = () => {
-    aborted = true
+  let paused = false
+  const abort = (reason) => {
+    if (!aborted) {
+      aborted = true
+      handler.onError(reason)
+    }
+  }
+  const resume = () => {
+    if (paused && !aborted) {
+      handler.onComplete()
+      paused = false
+    }
   }
-  const resume = () => {}
 
+  const { statusCode, headers } = entry
   try {
     handler.onConnect(abort)
     if (aborted) {
       return true
     }
 
-    handler.onHeaders(statusCode, null, resume, statusMessage, headers)
+    if (handler.onHeaders(statusCode, null, resume, null, headers) === false) {
+      paused = true
+    }
+
     if (aborted) {
       return true
     }
 
-    if (body.byteKength > 0) {
-      handler.onData(body)
-      if (aborted) {
-        return true
-      }
+    if (!paused) {
+      handler.onComplete()
     }
-
-    handler.onComplete()
   } catch (err) {
-    handler.onError(err)
+    abort(err)
   }
 
   return true

package/lib/interceptor/dns.js

@@ -1,9 +1,12 @@
 import net from 'node:net'
 import { resolve4 } from 'node:dns/promises'
+import { getFastNow } from '../utils.js'
 
 export default () => (dispatch) => {
+  const cache = new Map()
+
   return async (opts, handler) => {
-    if (!opts.dns) {
+    if (!opts || !opts.dns || !opts.origin) {
       return dispatch(opts, handler)
     }
 
@@ -13,9 +16,32 @@ export default () => (dispatch) => {
       return dispatch(opts, handler)
     }
 
-    const host = origin.host
-    const records = await resolve4(origin.hostname)
-    origin.hostname = records[Math.floor(Math.random() * records.length)]
+    const now = getFastNow()
+    const { host, hostname } = origin
+
+    const promiseOrRecords = cache.get(hostname)
+
+    let records = promiseOrRecords?.then ? await promiseOrRecords : promiseOrRecords
+
+    records = records.filter(({ expires }) => expires > now)
+    if (records == null || records.length === 0) {
+      const promise = resolve4(hostname, { ttl: true }).then((records) =>
+        records.map(({ address, ttl }) => ({ address, expires: now + 1e3 * ttl })),
+      )
+      cache.set(hostname, promise)
+      records = await promise
+      cache.set(hostname, records)
+    }
+
+    if (records == null || records.length === 0) {
+      throw Object.assign(new Error('No DNS records found for the specified hostname.'), {
+        code: 'ENOTFOUND',
+        hostname: origin.hostname,
+      })
+    }
+
+    const addresses = records.map(({ address }) => address)
+    origin.hostname = addresses[Math.floor(Math.random() * addresses.length)]
 
     return dispatch({ ...opts, origin, headers: { ...opts.headers, host } }, handler)
   }

package/lib/interceptor/dns.test.js

@@ -0,0 +1,9 @@
+import { test } from 'tap'
+import { request } from '../index.js'
+
+test('retry destroy pre response', async (t) => {
+  const { body, statusCode } = await request(`http://google.com`)
+  await body.dump()
+  t.equal(statusCode, 200)
+  t.end()
+})

package/lib/interceptor/log.js

@@ -1,7 +1,6 @@
 import { DecoratorHandler, parseHeaders } from '../utils.js'
 
 class Handler extends DecoratorHandler {
-  #handler
   #opts
   #logger
 
@@ -23,7 +22,6 @@ class Handler extends DecoratorHandler {
   constructor(opts, { handler }) {
     super(handler)
 
-    this.#handler = handler
     this.#opts = opts
     this.#logger = opts.logger.child({ ureq: opts })
 
@@ -41,7 +39,7 @@ class Handler extends DecoratorHandler {
 
     this.#logger.debug('upstream request started')
 
-    return this.#handler.onConnect((reason) => {
+    super.onConnect((reason) => {
       this.#aborted = true
       this.#abort(reason)
     })
@@ -62,7 +60,7 @@ class Handler extends DecoratorHandler {
       this.#logger.debug('upstream request socket closed')
     })
 
-    return this.#handler.onUpgrade(statusCode, null, socket, headers)
+    super.onUpgrade(statusCode, null, socket, headers)
   }
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
@@ -71,7 +69,7 @@ class Handler extends DecoratorHandler {
     this.#statusCode = statusCode
     this.#headers = headers
 
-    return this.#handler.onHeaders(statusCode, null, resume, statusMessage, headers)
+    return super.onHeaders(statusCode, null, resume, null, headers)
   }
 
   onData(chunk) {
@@ -81,7 +79,7 @@ class Handler extends DecoratorHandler {
 
     this.#pos += chunk.length
 
-    return this.#handler.onData(chunk)
+    return super.onData(chunk)
   }
 
   onComplete() {
@@ -101,7 +99,7 @@ class Handler extends DecoratorHandler {
       'upstream request completed',
     )
 
-    return this.#handler.onComplete()
+    super.onComplete()
   }
 
   onError(err) {
@@ -126,7 +124,7 @@ class Handler extends DecoratorHandler {
       this.#logger.error(data, 'upstream request failed')
     }
 
-    return this.#handler.onError(err)
+    super.onError(err)
   }
 }
 

package/lib/interceptor/proxy.js

@@ -3,18 +3,16 @@ import createError from 'http-errors'
 import { DecoratorHandler, parseHeaders } from '../utils.js'
 
 class Handler extends DecoratorHandler {
-  #handler
   #opts
 
   constructor(proxyOpts, { handler }) {
     super(handler)
 
-    this.#handler = handler
     this.#opts = proxyOpts
   }
 
   onUpgrade(statusCode, rawHeaders, socket, headers = parseHeaders(rawHeaders)) {
-    return this.#handler.onUpgrade(
+    super.onUpgrade(
       statusCode,
       reduceHeaders(
         {
@@ -34,7 +32,7 @@ class Handler extends DecoratorHandler {
   }
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
-    return this.#handler.onHeaders(
+    return super.onHeaders(
       statusCode,
       reduceHeaders(
         {
@@ -50,7 +48,7 @@ class Handler extends DecoratorHandler {
         [],
       ),
       resume,
-      statusMessage,
+      null,
     )
   }
 }

package/lib/interceptor/redirect.js

@@ -5,27 +5,25 @@ const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
 
 class Handler extends DecoratorHandler {
   #dispatch
-  #handler
   #opts
   #maxCount
 
-  #abort = null
+  #abort
   #aborted = false
   #reason = null
   #headersSent = false
   #count = 0
-  #location = ''
+  #location
   #history = []
 
   constructor(opts, { dispatch, handler }) {
     super(handler)
 
     this.#dispatch = dispatch
-    this.#handler = handler
     this.#opts = opts
     this.#maxCount = Number.isFinite(opts.follow) ? opts.follow : (opts.follow?.count ?? 0)
 
-    this.#handler.onConnect((reason) => {
+    super.onConnect((reason) => {
       this.#aborted = true
       if (this.#abort) {
         this.#abort(reason)
@@ -44,14 +42,14 @@ class Handler extends DecoratorHandler {
   }
 
   onUpgrade(statusCode, rawHeaders, socket, headers) {
-    return this.#handler.onUpgrade(statusCode, rawHeaders, socket, headers)
+    super.onUpgrade(statusCode, rawHeaders, socket, headers)
   }
 
-  onHeaders(statusCode, rawHeaders, resume, statusText, headers = parseHeaders(rawHeaders)) {
+  onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
     if (redirectableStatusCodes.indexOf(statusCode) === -1) {
       assert(!this.#headersSent)
       this.#headersSent = true
-      return this.#handler.onHeaders(statusCode, null, resume, statusText, headers)
+      return super.onHeaders(statusCode, null, resume, null, headers)
     }
 
     if (isDisturbed(this.#opts.body)) {
@@ -71,7 +69,7 @@ class Handler extends DecoratorHandler {
       if (!this.#opts.follow(this.#location, this.#count, this.#opts)) {
         assert(!this.#headersSent)
         this.#headersSent = true
-        return this.#handler.onHeaders(statusCode, null, resume, statusText, headers)
+        return super.onHeaders(statusCode, null, resume, null, headers)
       }
     } else {
       if (this.#count >= this.#maxCount) {
@@ -128,7 +126,7 @@ class Handler extends DecoratorHandler {
         servers and browsers implementors, we ignore the body as there is no specified way to eventually parse it.
       */
     } else {
-      return this.#handler.onData(chunk)
+      return super.onData(chunk)
     }
   }
 
@@ -147,12 +145,12 @@ class Handler extends DecoratorHandler {
 
       this.#dispatch(this.#opts, this)
     } else {
-      return this.#handler.onComplete(trailers)
+      super.onComplete(trailers)
     }
   }
 
   onError(error) {
-    return this.#handler.onError(error)
+    super.onError(error)
   }
 }
 

package/lib/interceptor/response-error.js

@@ -2,21 +2,21 @@ import createHttpError from 'http-errors'
 import { DecoratorHandler, parseHeaders } from '../utils.js'
 
 class Handler extends DecoratorHandler {
-  #handler
-
   #statusCode = 0
   #contentType
   #decoder
   #headers
   #body = ''
   #opts
-  #errored = false
 
   constructor(opts, { handler }) {
     super(handler)
 
     this.#opts = opts
-    this.#handler = handler
+  }
+
+  #checkContentType(contentType) {
+    return (this.#contentType ?? '').indexOf(contentType) === 0
   }
 
   onConnect(abort) {
@@ -25,9 +25,8 @@ class Handler extends DecoratorHandler {
     this.#decoder = null
     this.#headers = null
     this.#body = ''
-    this.#errored = false
 
-    return this.#handler.onConnect(abort)
+    super.onConnect(abort)
   }
 
   onHeaders(statusCode, rawHeaders, resume, statusMessage, headers = parseHeaders(rawHeaders)) {
@@ -36,28 +35,27 @@ class Handler extends DecoratorHandler {
     this.#contentType = headers['content-type']
 
     if (this.#statusCode < 400) {
-      return this.#handler.onHeaders(statusCode, null, resume, statusMessage, headers)
+      return super.onHeaders(statusCode, null, resume, null, headers)
     }
 
-    // TODO (fix): Check content length
-    if (this.#contentType === 'application/json' || this.#contentType === 'text/plain') {
+    if (this.#checkContentType('application/json') || this.#checkContentType('text/plain')) {
       this.#decoder = new TextDecoder('utf-8')
     }
   }
 
   onData(chunk) {
-    if (this.#statusCode >= 400) {
-      this.#body += this.#decoder?.decode(chunk, { stream: true }) ?? ''
-    } else {
-      return this.#handler.onData(chunk)
+    if (this.#statusCode < 400) {
+      return super.onData(chunk)
     }
+
+    this.#body += this.#decoder?.decode(chunk, { stream: true }) ?? ''
   }
 
   onComplete(rawTrailers) {
     if (this.#statusCode >= 400) {
       this.#body += this.#decoder?.decode(undefined, { stream: false }) ?? ''
 
-      if (this.#contentType === 'application/json') {
+      if (this.#checkContentType('application/json')) {
         try {
           this.#body = JSON.parse(this.#body)
         } catch {
@@ -65,10 +63,7 @@ class Handler extends DecoratorHandler {
         }
       }
 
-      this.#errored = true
-
       let err
-
       const stackTraceLimit = Error.stackTraceLimit
       Error.stackTraceLimit = 0
       try {
@@ -76,18 +71,15 @@ class Handler extends DecoratorHandler {
       } finally {
         Error.stackTraceLimit = stackTraceLimit
       }
-      this.#handler.onError(this.#decorateError(err))
+
+      super.onError(this.#decorateError(err))
     } else {
-      this.#handler.onComplete(rawTrailers)
+      super.onComplete(rawTrailers)
     }
   }
 
   onError(err) {
-    if (this.#errored) {
-      // Do nothing...
-    } else {
-      this.#handler.onError(this.#decorateError(err))
-    }
+    super.onError(this.#decorateError(err))
   }
 
   #decorateError(err) {
@@ -123,13 +115,13 @@ class Handler extends DecoratorHandler {
       }
 
       return err
-    } catch {
-      return err
+    } catch (er) {
+      return new AggregateError([er, err])
     }
   }
 }
 
 export default () => (dispatch) => (opts, handler) =>
-  opts.error !== false && opts.throwOnError !== false
+  opts.throwOnError !== false
     ? dispatch(opts, new Handler(opts, { handler }))
     : dispatch(opts, handler)