@nxtedition/nxt-undici 6.2.19 → 6.2.22

package/lib/interceptor/cache.js

@@ -4,6 +4,7 @@ import { SqliteCacheStore } from '../sqlite-cache-store.js'
 
 const DEFAULT_STORE = new SqliteCacheStore({ location: ':memory:' })
 const DEFAULT_MAX_ENTRY_SIZE = 128 * 1024
+const DEFAULT_MAX_ENTRY_TTL = 14 * 24 * 3600
 const NOOP = () => {}
 
 class CacheHandler extends DecoratorHandler {
@@ -12,6 +13,7 @@ class CacheHandler extends DecoratorHandler {
   #store
   #logger
   #maxEntrySize
+  #maxEntryTTL
 
   constructor(key, { store, logger, handler, maxEntrySize }) {
     super(handler)
@@ -21,6 +23,7 @@ class CacheHandler extends DecoratorHandler {
     this.#value = null
     this.#store = store
     this.#maxEntrySize = maxEntrySize ?? store.maxEntrySize ?? DEFAULT_MAX_ENTRY_SIZE
+    this.#maxEntryTTL = maxEntrySize ?? store.maxEntryTTL ?? DEFAULT_MAX_ENTRY_TTL
   }
 
   onConnect(abort) {
@@ -124,7 +127,7 @@ class CacheHandler extends DecoratorHandler {
         body: [],
         start,
         end,
-        deleteAt: cachedAt + ttl * 1e3,
+        deleteAt: cachedAt + Math.min(ttl, this.#maxEntryTTL) * 1e3,
         statusCode,
         statusMessage: '',
         headers,

package/lib/request.js

@@ -163,7 +163,14 @@ export function request(dispatch, url, opts) {
   let origin = url.origin
   if (!origin) {
     const protocol = url.protocol ?? 'http:'
-    const host = url.host ?? `${url.hostname}:${url.port ?? (protocol === 'https:' ? 443 : 80)}`
+    const host =
+      url.host ??
+      (url.hostname ? `${url.hostname}:${url.port ?? (protocol === 'https:' ? 443 : 80)}` : null)
+
+    if (!host || !protocol) {
+      throw new InvalidArgumentError('invalid url')
+    }
+
     origin = `${protocol}//${host}`
   }
 

package/lib/sqlite-cache-store.js

@@ -4,9 +4,6 @@ import { parseRangeHeader } from './utils.js'
 
 const VERSION = 6
 
-// 2gb
-const MAX_ENTRY_SIZE = 2 * 1000 * 1000 * 1000
-
 /**
  * @typedef {import('undici-types/cache-interceptor.d.ts').default.CacheStore} CacheStore
  * @implements {CacheStore}
@@ -28,9 +25,6 @@ const MAX_ENTRY_SIZE = 2 * 1000 * 1000 * 1000
  * }} SqliteStoreValue
  */
 export class SqliteCacheStore {
-  #maxEntrySize = MAX_ENTRY_SIZE
-  #maxEntryCount = 16 * 1024
-
   /**
    * @type {import('node:sqlite').DatabaseSync}
    */
@@ -57,57 +51,14 @@ export class SqliteCacheStore {
   #deleteByUrlQuery
 
   /**
-   * @type {import('node:sqlite').StatementSync}
-   */
-  #countEntriesQuery
-
-  /**
-   * @type {import('node:sqlite').StatementSync | null}
+   * @type {NodeJS.Timeout}
    */
-  #deleteOldValuesQuery
+  #pruneInterval
 
   /**
    * @param {import('undici-types/cache-interceptor.d.ts').default.SqliteCacheStoreOpts & { maxEntryCount?: number} | undefined} opts
    */
   constructor(opts) {
-    if (opts) {
-      if (typeof opts !== 'object') {
-        throw new TypeError('SqliteCacheStore options must be an object')
-      }
-
-      if (opts.maxEntrySize !== undefined) {
-        if (
-          typeof opts.maxEntrySize !== 'number' ||
-          !Number.isInteger(opts.maxEntrySize) ||
-          opts.maxEntrySize < 0
-        ) {
-          throw new TypeError(
-            'SqliteCacheStore options.maxEntrySize must be a non-negative integer',
-          )
-        }
-
-        if (opts.maxEntrySize > MAX_ENTRY_SIZE) {
-          throw new TypeError('SqliteCacheStore options.maxEntrySize must be less than 2gb')
-        }
-
-        this.#maxEntrySize = opts.maxEntrySize
-      }
-
-      const maxEntryCount = opts.maxEntryCount ?? opts.maxCount
-      if (maxEntryCount !== undefined) {
-        if (
-          typeof maxEntryCount !== 'number' ||
-          !Number.isInteger(maxEntryCount) ||
-          maxEntryCount < 0
-        ) {
-          throw new TypeError(
-            'SqliteCacheStore options.maxEntryCount must be a non-negative integer',
-          )
-        }
-        this.#maxEntryCount = maxEntryCount
-      }
-    }
-
     this.#db = new DatabaseSync(opts?.location ?? ':memory:')
 
     this.#db.exec(`
@@ -180,30 +131,17 @@ export class SqliteCacheStore {
       `DELETE FROM cacheInterceptorV${VERSION} WHERE url = ?`,
     )
 
-    this.#countEntriesQuery = this.#db.prepare(
-      `SELECT COUNT(*) AS total FROM cacheInterceptorV${VERSION}`,
-    )
-
     this.#deleteExpiredValuesQuery = this.#db.prepare(
       `DELETE FROM cacheInterceptorV${VERSION} WHERE deleteAt <= ?`,
     )
 
-    this.#deleteOldValuesQuery =
-      this.#maxEntryCount === Infinity
-        ? null
-        : this.#db.prepare(`
-        DELETE FROM cacheInterceptorV${VERSION}
-        WHERE id IN (
-          SELECT
-            id
-          FROM cacheInterceptorV${VERSION}
-          ORDER BY cachedAt DESC
-          LIMIT ?
-        )
-      `)
+    this.#pruneInterval = setInterval(() => {
+      this.#deleteExpiredValuesQuery.run(Date.now())
+    }, 60e3)
   }
 
   close() {
+    clearInterval(this.#pruneInterval)
     this.#db.close()
   }
 
@@ -227,16 +165,11 @@ export class SqliteCacheStore {
     assertCacheValue(value)
 
     const body = Array.isArray(value.body) ? Buffer.concat(value.body) : value.body
-    if ((body?.byteLength ?? 0) > this.#maxEntrySize) {
-      return
-    }
 
     assert(Number.isFinite(value.start))
     assert(Number.isFinite(value.end))
     assert(!body || body?.byteLength === value.end - value.start)
 
-    this.#prune()
-
     this.#insertValueQuery.run(
       makeValueUrl(key),
       key.method,
@@ -266,39 +199,6 @@ export class SqliteCacheStore {
     this.#deleteByUrlQuery.run(makeValueUrl(key))
   }
 
-  #prune() {
-    if (this.size <= this.#maxEntryCount) {
-      return 0
-    }
-
-    {
-      const removed = this.#deleteExpiredValuesQuery.run(Date.now()).changes
-      if (removed) {
-        return removed
-      }
-    }
-
-    {
-      const removed = this.#deleteOldValuesQuery?.run(
-        Math.max(Math.floor(this.#maxEntryCount * 0.1), 1),
-      ).changes
-      if (removed) {
-        return removed
-      }
-    }
-
-    return 0
-  }
-
-  /**
-   * Counts the number of rows in the cache
-   * @returns {Number}
-   */
-  get size() {
-    const { total } = this.#countEntriesQuery.get()
-    return total
-  }
-
   /**
    * @param {import('undici-types/cache-interceptor.d.ts').default.CacheKey} key
    * @param {boolean} [canBeExpired=false]
@@ -407,22 +307,30 @@ function makeResult(value) {
   }
 }
 
+function printType(val) {
+  return val == null ? 'null' : typeof val === 'object' ? val.constructor.name : typeof val
+}
+
 /**
  * @param {any} key
  */
 function assertCacheKey(key) {
-  if (typeof key !== 'object') {
-    throw new TypeError(`expected key to be object, got ${typeof key}`)
+  if (typeof key !== 'object' || key == null) {
+    throw new TypeError(`expected key to be object, got ${typeof printType(key)} [${key}]`)
   }
 
   for (const property of ['origin', 'method', 'path']) {
     if (typeof key[property] !== 'string') {
-      throw new TypeError(`expected key.${property} to be string, got ${typeof key[property]}`)
+      throw new TypeError(
+        `expected key.${property} to be string, got ${printType(key[property])} [${key[property]}]`,
+      )
     }
   }
 
   if (key.headers !== undefined && typeof key.headers !== 'object') {
-    throw new TypeError(`expected headers to be object, got ${typeof key}`)
+    throw new TypeError(
+      `expected headers to be object, got ${typeof printType(key)} [${key.headers}]`,
+    )
   }
 }
 
@@ -430,31 +338,39 @@ function assertCacheKey(key) {
  * @param {any} value
  */
 function assertCacheValue(value) {
-  if (typeof value !== 'object') {
-    throw new TypeError(`expected value to be object, got ${typeof value}`)
+  if (typeof value !== 'object' || value == null) {
+    throw new TypeError(`expected value to be object, got ${typeof printType(value)}`)
   }
 
   for (const property of ['statusCode', 'cachedAt', 'staleAt', 'deleteAt']) {
     if (typeof value[property] !== 'number') {
-      throw new TypeError(`expected value.${property} to be number, got ${typeof value[property]}`)
+      throw new TypeError(
+        `expected value.${property} to be number, got ${printType(value[property])} [${value[property]}]`,
+      )
     }
   }
 
   if (typeof value.statusMessage !== 'string') {
     throw new TypeError(
-      `expected value.statusMessage to be string, got ${typeof value.statusMessage}`,
+      `expected value.statusMessage to be string, got ${printType(value.statusMessage)} [${value.statusMessage}]`,
     )
   }
 
   if (value.headers != null && typeof value.headers !== 'object') {
-    throw new TypeError(`expected value.rawHeaders to be object, got ${typeof value.headers}`)
+    throw new TypeError(
+      `expected value.rawHeaders to be object, got ${printType(value.headers)} [${value.headers}]`,
+    )
   }
 
   if (value.vary !== undefined && typeof value.vary !== 'object') {
-    throw new TypeError(`expected value.vary to be object, got ${typeof value.vary}`)
+    throw new TypeError(
+      `expected value.vary to be object, got ${printType(value.vary)} [${value.vary}]`,
+    )
   }
 
   if (value.etag !== undefined && typeof value.etag !== 'string') {
-    throw new TypeError(`expected value.etag to be string, got ${typeof value.etag}`)
+    throw new TypeError(
+      `expected value.etag to be string, got ${printType(value.etag)} [${value.etag}]`,
+    )
   }
 }

package/package.json

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