@nxtedition/nxt-undici 7.3.10 → 7.3.12

package/lib/sqlite-cache-store.js

@@ -63,6 +63,9 @@ export class SqliteCacheStore {
    */
   #evictQuery
 
+  #insertBatch = []
+  #closed = false
+
   /**
    * @param {import('undici-types/cache-interceptor.d.ts').default.SqliteCacheStoreOpts & { maxSize?: number } | undefined} opts
    */
@@ -170,6 +173,10 @@ export class SqliteCacheStore {
 
   close() {
     stores.delete(this)
+    if (this.#insertBatch.length > 0) {
+      this.#flush()
+    }
+    this.#closed = true
     this.#db.close()
   }
 
@@ -180,6 +187,10 @@ export class SqliteCacheStore {
   get(key) {
     assertCacheKey(key)
 
+    if (this.#closed) {
+      return undefined
+    }
+
     const value = this.#findValue(key)
     return value ? makeResult(value) : undefined
   }
@@ -220,39 +231,117 @@ export class SqliteCacheStore {
       )
     }
 
+    if (this.#closed) {
+      return
+    }
+
+    if (this.#insertBatch.length === 0) {
+      setImmediate(this.#flush)
+    }
+
+    this.#insertBatch.push({
+      url: makeValueUrl(key),
+      method: key.method,
+      body,
+      start: value.start,
+      end: value.end,
+      deleteAt: value.deleteAt,
+      statusCode: value.statusCode,
+      statusMessage: value.statusMessage,
+      headers: value.headers ? JSON.stringify(value.headers) : null,
+      etag: value.etag != null ? value.etag : null,
+      cacheControlDirectives: value.cacheControlDirectives
+        ? JSON.stringify(value.cacheControlDirectives)
+        : null,
+      vary: value.vary ? JSON.stringify(value.vary) : null,
+      cachedAt: value.cachedAt,
+      staleAt: value.staleAt,
+    })
+  }
+
+  #flush = () => {
+    if (this.#insertBatch.length === 0) return
+    if (this.#closed) {
+      this.#insertBatch.length = 0
+      return
+    }
     try {
-      this.#insert(key, value, body)
-    } catch (err) {
-      if (err?.errcode === 13 /* SQLITE_FULL */) {
+      const startTime = performance.now()
+      for (let retryCount = 0; true; retryCount++) {
+        let n = 0
         try {
-          this.#evictQuery.run(256)
-          this.#insert(key, value, body)
-        } catch (evictErr) {
-          process.emitWarning(evictErr)
+          this.#db.exec('BEGIN')
+          while (n < this.#insertBatch.length) {
+            const {
+              url,
+              method,
+              body,
+              start,
+              end,
+              deleteAt,
+              statusCode,
+              statusMessage,
+              headers,
+              etag,
+              cacheControlDirectives,
+              vary,
+              cachedAt,
+              staleAt,
+            } = this.#insertBatch[n++]
+            this.#insertValueQuery.run(
+              url,
+              method,
+              body,
+              start,
+              end,
+              deleteAt,
+              statusCode,
+              statusMessage,
+              headers,
+              etag,
+              cacheControlDirectives,
+              vary,
+              cachedAt,
+              staleAt,
+            )
+            if ((n & 0xf) === 0 && performance.now() - startTime > 10) {
+              break
+            }
+          }
+          this.#db.exec('COMMIT')
+          this.#insertBatch.splice(0, n)
+          break
+        } catch (err) {
+          // ROLLBACK is required: a failed statement leaves the connection with
+          // an open transaction; without it the next BEGIN would throw.
+          // On SQLITE_FULL, SQLite automatically rolls back the transaction, so
+          // the explicit ROLLBACK may fail with "no transaction is active" — ignore it.
+          try {
+            this.#db.exec('ROLLBACK')
+          } catch {
+            // already rolled back automatically
+            // TODO (fix): Check that the error is what we expect (something like "no transaction is active")...
+          }
+
+          if (err?.errcode === 13 /* SQLITE_FULL */ && retryCount < 3) {
+            this.#evictQuery.run(256)
+          } else {
+            // If BEGIN failed (n=0) clear the whole batch to avoid an infinite
+            // retry loop. If an INSERT/COMMIT failed, only clear the entries
+            // that were part of the attempted transaction.
+            this.#insertBatch.splice(0, n || this.#insertBatch.length)
+            throw err
+          }
         }
-      } else {
-        process.emitWarning(err)
       }
+    } catch (err) {
+      process.emitWarning(err)
     }
-  }
 
-  #insert(key, value, body) {
-    this.#insertValueQuery.run(
-      makeValueUrl(key),
-      key.method,
-      body,
-      value.start,
-      value.end,
-      value.deleteAt,
-      value.statusCode,
-      value.statusMessage,
-      value.headers ? JSON.stringify(value.headers) : null,
-      value.etag != null ? value.etag : null,
-      value.cacheControlDirectives ? JSON.stringify(value.cacheControlDirectives) : null,
-      value.vary ? JSON.stringify(value.vary) : null,
-      value.cachedAt,
-      value.staleAt,
-    )
+    if (this.#insertBatch.length > 0) {
+      // If we weren't able to flush the entire batch within the time limit, schedule another flush.
+      setImmediate(this.#flush)
+    }
   }
 
   /**
@@ -272,20 +361,32 @@ export class SqliteCacheStore {
       return undefined
     }
 
+    const url = makeValueUrl(key)
+    const now = getFastNow()
+    const requestedStart = range?.start ?? 0
+
     /**
      * @type {SqliteStoreValue[]}
      */
-    const values = this.#getValuesQuery.all(
-      makeValueUrl(key),
-      method,
-      range?.start ?? 0,
-      getFastNow(),
-    )
+    const values = this.#getValuesQuery.all(url, method, requestedStart, now)
+
+    for (const entry of this.#insertBatch) {
+      if (
+        entry.url === url &&
+        entry.method === method &&
+        entry.start <= requestedStart &&
+        entry.deleteAt > now
+      ) {
+        values.push(entry)
+      }
+    }
 
     if (values.length === 0) {
       return undefined
     }
 
+    values.sort((a, b) => b.cachedAt - a.cachedAt)
+
     for (const value of values) {
       // TODO (fix): Allow full and partial match?
       if (range && (range.start !== value.start || range.end !== value.end)) {

package/package.json

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