@nxtedition/nxt-undici 6.0.1 → 6.0.2

package/lib/cache/sqlite-cache-store.js

@@ -1,3 +1,5 @@
+'use strict'
+
 import { assertCacheKey, assertCacheValue } from './util.js'
 
 let DatabaseSync
@@ -13,16 +15,24 @@ const VERSION = 3
 const MAX_ENTRY_SIZE = 2 * 1000 * 1000 * 1000
 
 /**
- * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheStore} CacheStore
+ * @typedef {import('undici-types/cache-interceptor.d.ts').default.CacheStore} CacheStore
  * @implements {CacheStore}
  *
  * @typedef {{
  *  id: Readonly<number>
- *  headers?: Record<string, string | string[]>
- *  vary?: string | object
- *  body: string
- * } & import('../../types/cache-interceptor.d.ts').default.CacheValue} SqliteStoreValue
+ *  body?: Buffer
+ *  statusCode: number
+ *  statusMessage: string
+ *  headers?: string
+ *  vary?: string
+ *  etag?: string
+ *  cacheControlDirectives?: string
+ *  cachedAt: number
+ *  staleAt: number
+ *  deleteAt: number
+ * }} SqliteStoreValue
  */
+
 export class SqliteCacheStore {
   #maxEntrySize = MAX_ENTRY_SIZE
   #maxCount = Infinity
@@ -68,13 +78,9 @@ export class SqliteCacheStore {
   #deleteOldValuesQuery
 
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.SqliteCacheStoreOpts | undefined} opts
+   * @param {import('undici-types/cache-interceptor.d.ts').default.SqliteCacheStoreOpts | undefined} opts
    */
   constructor(opts) {
-    if (!DatabaseSync) {
-      throw new Error('SqliteCacheStore requires node:sqlite')
-    }
-
     if (opts) {
       if (typeof opts !== 'object') {
         throw new TypeError('SqliteCacheStore options must be an object')
@@ -224,8 +230,8 @@ export class SqliteCacheStore {
   }
 
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
-   * @returns {import('../../types/cache-interceptor.d.ts').default.GetResult | undefined}
+   * @param {import('undici-types/cache-interceptor.d.ts').default.CacheKey} key
+   * @returns {import('undici-types/cache-interceptor.d.ts').default.GetResult | undefined}
    */
   get(key) {
     assertCacheKey(key)
@@ -237,15 +243,15 @@ export class SqliteCacheStore {
     }
 
     /**
-     * @type {import('../../types/cache-interceptor.d.ts').default.GetResult}
+     * @type {import('undici-types/cache-interceptor.d.ts').default.GetResult}
      */
     const result = {
-      body: Buffer.from(value.body),
+      body: value.body ? Buffer.from(value.body) : null,
       statusCode: value.statusCode,
       statusMessage: value.statusMessage,
       headers: value.headers ? JSON.parse(value.headers) : undefined,
       etag: value.etag ? value.etag : undefined,
-      vary: value.vary ?? undefined,
+      vary: value.vary ? JSON.parse(value.vary) : undefined,
       cacheControlDirectives: value.cacheControlDirectives
         ? JSON.parse(value.cacheControlDirectives)
         : undefined,
@@ -258,14 +264,14 @@ export class SqliteCacheStore {
   }
 
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheValue & { body: Buffer | null }} value
+   * @param {import('undici-types/cache-interceptor.d.ts').default.CacheKey} key
+   * @param {import('undici-types/cache-interceptor.d.ts').default.CacheValue & { body: Buffer | Array<Buffer> | null }} value
    */
   set(key, value) {
-    assertCacheKey(value)
+    assertCacheKey(key)
     assertCacheValue(value)
 
-    const body = value.body
+    const body = Array.isArray(value.body) ? Buffer.concat(value.body) : value.body
     const size = body ? body.byteLength : 0
 
     if (size > this.#maxEntrySize) {
@@ -314,7 +320,7 @@ export class SqliteCacheStore {
   }
 
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
+   * @param {import('undici-types/cache-interceptor.d.ts').default.CacheKey} key
    */
   delete(key) {
     if (typeof key !== 'object') {
@@ -358,7 +364,7 @@ export class SqliteCacheStore {
   }
 
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
+   * @param {import('undici-types/cache-interceptor.d.ts').default.CacheKey} key
    * @returns {string}
    */
   #makeValueUrl(key) {
@@ -366,9 +372,9 @@ export class SqliteCacheStore {
   }
 
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
+   * @param {import('undici-types/cache-interceptor.d.ts').default.CacheKey} key
    * @param {boolean} [canBeExpired=false]
-   * @returns {(SqliteStoreValue & { vary?: Record<string, string[]> }) | undefined}
+   * @returns {SqliteStoreValue | undefined}
    */
   #findValue(key, canBeExpired = false) {
     const url = this.#makeValueUrl(key)
@@ -396,10 +402,10 @@ export class SqliteCacheStore {
           return undefined
         }
 
-        value.vary = JSON.parse(value.vary)
+        const vary = JSON.parse(value.vary)
 
-        for (const header in value.vary) {
-          if (!headerValueEquals(headers[header], value.vary[header])) {
+        for (const header in vary) {
+          if (!headerValueEquals(headers[header], vary[header])) {
             matches = false
             break
           }

package/lib/index.js

@@ -103,7 +103,6 @@ function wrapDispatch(dispatcher) {
             dns: opts.dns ?? true,
             connect: opts.connect,
             lookup: opts.lookup ?? defaultLookup,
-            maxRedirections: 0, // TODO (fix): Ugly hack to disable undici redirections.
           },
           handler,
         )

package/lib/interceptor/cache.js

@@ -2,6 +2,7 @@ import { SqliteCacheStore } from '../cache/sqlite-cache-store.js'
 import { DecoratorHandler, parseCacheControl } from '../utils.js'
 
 const DEFAULT_STORE = new SqliteCacheStore({ location: ':memory:' })
+const MAX_ENTRY_SIZE = 128 * 1024
 
 class CacheHandler extends DecoratorHandler {
   #value
@@ -27,19 +28,18 @@ class CacheHandler extends DecoratorHandler {
       return super.onHeaders(statusCode, headers, resume)
     }
 
-    if (headers.vary === '*') {
+    if (headers.vary === '*' || headers.trailers) {
       // Not cacheble...
       return super.onHeaders(statusCode, headers, resume)
     }
 
-    const cacheControl = parseCacheControl(headers['cache-control'])
     const contentLength = headers['content-length'] ? Number(headers['content-length']) : Infinity
-
-    if (contentLength) {
+    if (Number.isFinite(contentLength) && contentLength > MAX_ENTRY_SIZE) {
       // We don't support caching responses with body...
       return super.onHeaders(statusCode, headers, resume)
     }
 
+    const cacheControl = parseCacheControl(headers['cache-control'])
     if (
       !cacheControl ||
       !cacheControl.public ||
@@ -83,7 +83,8 @@ class CacheHandler extends DecoratorHandler {
     const cachedAt = Date.now()
 
     this.#value = {
-      body: null,
+      body: [],
+      size: 0,
       deleteAt: cachedAt + ttl * 1e3,
       statusCode,
       statusMessage: '',
@@ -99,15 +100,25 @@ class CacheHandler extends DecoratorHandler {
   }
 
   onData(chunk) {
-    this.#value = null
+    if (this.#value) {
+      this.#value.size += chunk.length
+      this.#value.body.push(chunk)
+
+      if (this.#value.size > MAX_ENTRY_SIZE) {
+        this.#value = null
+        this.#value.size = 0
+      }
+    }
+
     return super.onData(chunk)
   }
 
-  onComplete() {
-    if (this.#value) {
+  onComplete(trailers) {
+    if (this.#value && (!trailers || Object.keys(trailers).length === 0)) {
       this.#store.set(this.#opts, this.#value)
     }
-    super.onComplete()
+
+    super.onComplete(trailers)
   }
 }
 

package/lib/interceptor/dns.js

@@ -1,9 +1,56 @@
 import net from 'node:net'
 import { resolve4 } from 'node:dns/promises'
-import { getFastNow } from '../utils.js'
+import { DecoratorHandler, getFastNow } from '../utils.js'
+
+function noop() {}
+
+const MAX_TTL = 10e3
+
+class Handler extends DecoratorHandler {
+  #callback
+
+  constructor(handler, callback) {
+    super(handler)
+    this.#callback = callback
+  }
+
+  onComplete(trailers) {
+    this.#callback(null)
+    super.onComplete(trailers)
+  }
+
+  onError(err) {
+    this.#callback(err)
+    super.onError(err)
+  }
+}
 
 export default () => (dispatch) => {
   const cache = new Map()
+  const resolvers = new Map()
+
+  function resolve(hostname) {
+    let promise = resolvers.get(hostname)
+    if (!promise) {
+      promise = resolve4(hostname, { ttl: true })
+        .then((records) => {
+          const now = getFastNow()
+          const prev = cache.get(hostname)
+          const next = records.map(({ address, ttl }) => ({
+            address,
+            expires: now + Math.min(MAX_TTL, 1e3 * ttl),
+            stats: prev?.find((x) => x.address === address)?.stats || { pending: 0, errored: 0 },
+          }))
+          cache.set(hostname, next)
+          return next
+        })
+        .finally(() => {
+          resolvers.delete(hostname)
+        })
+      resolvers.set(hostname, promise)
+    }
+    return promise
+  }
 
   return async (opts, handler) => {
     if (!opts || !opts.dns || !opts.origin) {
@@ -16,33 +63,58 @@ export default () => (dispatch) => {
       return dispatch(opts, handler)
     }
 
-    const now = getFastNow()
     const { host, hostname } = origin
 
-    const promiseOrRecords = cache.get(hostname)
+    const now = getFastNow()
 
-    let records = promiseOrRecords?.then ? await promiseOrRecords : promiseOrRecords
+    let records = cache.get(hostname)
 
-    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.every((x) => x.stats.errored || x.expires < now)) {
+      records = await resolve(hostname)
+    } else if (records.some((x) => x.errored || x.expires + 1e3 > now)) {
+      resolve(hostname).catch(noop)
     }
 
-    if (records == null || records.length === 0) {
-      throw Object.assign(new Error('No DNS records found for the specified hostname.'), {
+    records.sort((a, b) => {
+      if (a.stats.errored !== b.stats.errored) {
+        return a.stats.errored - b.stats.errored
+      }
+
+      if (a.stats.pending !== b.stats.pending) {
+        return a.stats.pending - b.stats.pending
+      }
+
+      return 0
+    })
+
+    const record = records.find((x) => x.expires >= now)
+
+    if (!record) {
+      throw Object.assign(new Error(`No available DNS records found for ${hostname}`), {
         code: 'ENOTFOUND',
-        hostname: origin.hostname,
       })
     }
 
-    const addresses = records.map(({ address }) => address)
-    origin.hostname = addresses[Math.floor(Math.random() * addresses.length)]
+    origin.hostname = record.address
 
-    return dispatch({ ...opts, origin, headers: { ...opts.headers, host } }, handler)
+    record.stats.pending++
+    try {
+      return dispatch(
+        { ...opts, origin, headers: { ...opts.headers, host } },
+        new Handler(handler, (err) => {
+          record.pending--
+          if (err.name === 'AbortError') {
+            // Do nothing...
+          } else if (err.statusCode == null || err.statusCode >= 500) {
+            record.stats.errored++
+          } else {
+            record.stats.errored = 0
+          }
+        }),
+      )
+    } catch (err) {
+      record.stats.pending--
+      throw err
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/nxt-undici",
-  "version": "6.0.1",
+  "version": "6.0.2",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "main": "lib/index.js",
@@ -22,7 +22,8 @@
     "pinst": "^3.0.0",
     "prettier": "^3.4.1",
     "send": "^1.1.0",
-    "tap": "^21.0.1"
+    "tap": "^21.0.1",
+    "undici-types": "^7.2.3"
   },
   "scripts": {
     "prepare": "husky",