@nxtedition/nxt-undici 7.3.25 → 7.3.27

package/lib/sqlite-cache-store.js

@@ -78,6 +78,7 @@ export class SqliteCacheStore {
   #evictQuery
 
   #insertBatch = []
+  #insertSeq = 0
   #closed = false
 
   /**
@@ -142,7 +143,7 @@ export class SqliteCacheStore {
         AND start <= ?
         AND deleteAt > ?
       ORDER BY
-        cachedAt DESC
+        cachedAt DESC, id DESC
     `)
 
     this.#insertValueQuery = this.#db.prepare(`
@@ -177,6 +178,10 @@ export class SqliteCacheStore {
   }
 
   gc() {
+    if (this.#closed) {
+      return
+    }
+
     try {
       this.#db.exec('PRAGMA busy_timeout = 1000')
       this.#deleteExpiredValuesQuery.run(getFastNow())
@@ -218,8 +223,13 @@ export class SqliteCacheStore {
 
   close() {
     stores.delete(this)
+    // Drain the entire batch synchronously before closing. A plain #flush()
+    // only commits one time-budget slice and reschedules the rest via
+    // setImmediate; that deferred flush would see #closed and discard the
+    // remainder, silently losing entries. Pass final=true to ignore the
+    // budget and flush everything in one pass while #closed is still false.
     if (this.#insertBatch.length > 0) {
-      this.#flush()
+      this.#flush(true)
     }
     this.#closed = true
     this.#db.close()
@@ -285,6 +295,9 @@ export class SqliteCacheStore {
     }
 
     this.#insertBatch.push({
+      // Monotonic per-store sequence used only to break cachedAt ties in
+      // #findValue (newest write wins). Not persisted — #flush ignores it.
+      seq: this.#insertSeq++,
       url: makeValueUrl(key),
       method: key.method,
       body,
@@ -303,7 +316,7 @@ export class SqliteCacheStore {
     })
   }
 
-  #flush = () => {
+  #flush = (final = false) => {
     if (this.#insertBatch.length === 0) return
     if (this.#closed) {
       this.#insertBatch.length = 0
@@ -346,7 +359,7 @@ export class SqliteCacheStore {
               vary,
               cachedAt,
             )
-            if ((n & 0xf) === 0 && performance.now() - startTime > 10) {
+            if (!final && (n & 0xf) === 0 && performance.now() - startTime > 10) {
               break
             }
           }
@@ -407,6 +420,23 @@ export class SqliteCacheStore {
     const now = getFastNow()
     const requestedStart = range?.start ?? 0
 
+    if (this.#insertBatch.length === 0) {
+      // Fast path: rows arrive sorted (cachedAt DESC, id DESC) and there are
+      // no pending batch entries to merge, so fetch only the newest candidate.
+      // This covers misses and first-row hits (the overwhelmingly common
+      // cases) with a single row materialized — re-cached duplicates of a hot
+      // key would otherwise all be read including their blobs. Only when the
+      // newest row doesn't match (vary variant, range/206 mismatch) do we
+      // fall through to scan the full candidate set.
+      const value = this.#getValuesQuery.get(url, method, requestedStart, now)
+      if (value === undefined) {
+        return undefined
+      }
+      if (matchesValue(value, range, headers)) {
+        return value
+      }
+    }
+
     /**
      * @type {SqliteStoreValue[]}
      */
@@ -427,35 +457,68 @@ export class SqliteCacheStore {
       return undefined
     }
 
-    values.sort((a, b) => b.cachedAt - a.cachedAt)
+    // Newest representation wins. cachedAt is millisecond-resolution, so a
+    // re-cache within the same millisecond produces a tie; break it
+    // deterministically toward the freshest write: pending batch entries
+    // (tagged with a monotonic seq) are always newer than any flushed DB row,
+    // and within each source a higher seq/id wins.
+    if (values.length > 1) {
+      values.sort((a, b) => {
+        if (a.cachedAt !== b.cachedAt) {
+          return b.cachedAt - a.cachedAt
+        }
+        const aBatch = a.seq != null
+        const bBatch = b.seq != null
+        if (aBatch !== bBatch) {
+          return aBatch ? -1 : 1
+        }
+        if (aBatch) {
+          return b.seq - a.seq
+        }
+        return (b.id ?? 0) - (a.id ?? 0)
+      })
+    }
 
     for (const value of values) {
-      // TODO (fix): Allow full and partial match?
-      if (range && (range.start !== value.start || range.end !== value.end)) {
-        continue
+      if (matchesValue(value, range, headers)) {
+        return value
       }
+    }
+
+    return undefined
+  }
+}
 
-      if (value.vary) {
-        const vary = JSON.parse(value.vary)
-        let matches = true
+/**
+ * @param {SqliteStoreValue} value
+ * @param {import('./utils.js').RangeHeader | undefined} range
+ * @param {Record<string, string | string[]> | undefined} headers
+ * @returns {boolean}
+ */
+function matchesValue(value, range, headers) {
+  // TODO (fix): Allow full and partial match?
+  if (range && (range.start !== value.start || range.end !== value.end)) {
+    return false
+  }
 
-        for (const header in vary) {
-          if (!headerValueEquals(headers?.[header], vary[header])) {
-            matches = false
-            break
-          }
-        }
+  // A request without a Range header asks for the full representation, so
+  // a stored 206 partial (e.g. content-range bytes 0-4/100, which the SQL
+  // `start <= 0` filter does not exclude) must not be served verbatim.
+  if (!range && value.statusCode === 206) {
+    return false
+  }
 
-        if (!matches) {
-          continue
-        }
-      }
+  if (value.vary) {
+    const vary = JSON.parse(value.vary)
 
-      return value
+    for (const header in vary) {
+      if (!headerValueEquals(headers?.[header], vary[header])) {
+        return false
+      }
     }
-
-    return undefined
   }
+
+  return true
 }
 
 /**
@@ -472,15 +535,21 @@ function headerValueEquals(lhs, rhs) {
     return false
   }
 
-  if (Array.isArray(lhs) && Array.isArray(rhs)) {
-    if (lhs.length !== rhs.length) {
+  // A single-element array and the bare scalar denote the same logical header
+  // value (e.g. 'gzip' vs ['gzip']); normalize so an inconsistently-shaped
+  // selecting header doesn't cause an avoidable cache miss.
+  const a = Array.isArray(lhs) && lhs.length === 1 ? lhs[0] : lhs
+  const b = Array.isArray(rhs) && rhs.length === 1 ? rhs[0] : rhs
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
       return false
     }
 
-    return lhs.every((x, i) => x === rhs[i])
+    return a.every((x, i) => x === b[i])
   }
 
-  return lhs === rhs
+  return a === b
 }
 
 /**
@@ -493,8 +562,14 @@ function makeValueUrl(key) {
 
 function makeResult(value) {
   return {
+    // Batch entries (tagged with seq) must be copied: value.body is the exact
+    // Buffer still queued for flushing, so a consumer mutating the served body
+    // could corrupt the bytes about to be written. DB rows are safe to alias —
+    // node:sqlite allocates a fresh Uint8Array per read, so wrap it zero-copy.
     body: value.body
-      ? Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength)
+      ? value.seq != null
+        ? Buffer.from(value.body)
+        : Buffer.from(value.body.buffer, value.body.byteOffset, value.body.byteLength)
       : undefined,
     statusCode: value.statusCode,
     statusMessage: value.statusMessage,

package/lib/utils.js

@@ -291,7 +291,10 @@ export function parseHeaders(headers, obj) {
       const key = util.headerNameToString(key2)
       let val = obj[key]
 
-      if (val) {
+      // `key in obj`, not `if (val)`: an empty-string value ('') is a valid,
+      // present header. A truthy check would treat it as absent and overwrite
+      // it on a duplicate occurrence, silently dropping the first value.
+      if (key in obj) {
         if (!Array.isArray(val)) {
           val = [val]
           obj[key] = val
@@ -322,7 +325,9 @@ export function parseHeaders(headers, obj) {
       const key = util.headerNameToString(key2)
       let val = obj[key]
 
-      if (val) {
+      // See the array branch above: presence check, not truthiness, so a
+      // stored empty string is not clobbered by a later duplicate.
+      if (key in obj) {
         if (!Array.isArray(val)) {
           val = [val]
           obj[key] = val
@@ -332,7 +337,7 @@ export function parseHeaders(headers, obj) {
         } else {
           val.push(`${val2}`)
         }
-      } else if (val2 != null) {
+      } else {
         obj[key] = Array.isArray(val2)
           ? val2.filter((x) => x != null).map((x) => `${x}`)
           : `${val2}`
@@ -342,11 +347,6 @@ export function parseHeaders(headers, obj) {
     throw new Error('invalid argument: headers')
   }
 
-  // See https://github.com/nodejs/node/pull/46528
-  if (obj != null && 'content-length' in obj && 'content-disposition' in obj) {
-    obj['content-disposition'] = Buffer.from(obj['content-disposition']).toString('latin1')
-  }
-
   return obj
 }
 
@@ -379,10 +379,14 @@ export function decorateError(err, opts, { statusCode, headers, trailers, body }
       body = null
     }
 
-    if (
-      typeof body === 'string' &&
-      (!headers?.['content-type'] || headers['content-type'].startsWith('application/json'))
-    ) {
+    // A duplicated content-type response header arrives as an array (undici's
+    // parseHeaders collapses repeats); coerce to the first value before
+    // calling string methods, otherwise this throws and the catch below
+    // discards all decoration into an opaque AggregateError.
+    const contentType = Array.isArray(headers?.['content-type'])
+      ? headers['content-type'][0]
+      : headers?.['content-type']
+    if (typeof body === 'string' && (!contentType || contentType.startsWith('application/json'))) {
       try {
         body = JSON.parse(body)
       } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/nxt-undici",
-  "version": "7.3.25",
+  "version": "7.3.27",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "main": "lib/index.js",
@@ -23,6 +23,7 @@
     "eslint-plugin-n": "^17.24.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.4.0",
+    "mitata": "^1.0.34",
     "pino": "^10.3.1",
     "pinst": "^3.0.0",
     "prettier": "^3.8.1",