@nxtedition/cache 2.1.2 → 2.1.4

package/lib/index.js

@@ -100,7 +100,6 @@ export class Cache                                              extends EventEmi
   #location        
   #database                      = null
   #getQuery                       = null
-  #setQuery                       = null
   #delQuery                       = null
   #purgeStaleQuery                       = null
   #evictQuery                       = null
@@ -110,6 +109,8 @@ export class Cache                                              extends EventEmi
   #lockPurgeQuery                       = null
   #pageCountQuery                       = null
   #pageSizeQuery                       = null
+  #setQuery                       = null
+  #setBatch                                                                          = []
 
   #emitError(err       )       {
     if (this.listenerCount('error') > 0) {
@@ -202,7 +203,8 @@ export class Cache                                              extends EventEmi
 
         this.#database.exec(`
           PRAGMA journal_mode = WAL;
-          PRAGMA synchronous = NORMAL;
+          PRAGMA synchronous = OFF;
+          PRAGMA wal_autocheckpoint = 10000;
           PRAGMA cache_size = -${Math.ceil(maxSize / 1024 / 8)};
           PRAGMA mmap_size = ${maxSize};
           PRAGMA max_page_count = ${Math.ceil(maxSize / 4096)};
@@ -375,6 +377,7 @@ export class Cache                                              extends EventEmi
       this.#memory?.purgeStale(Date.now())
       this.#purgeStaleQuery?.run(Date.now())
       this.#lockPurgeQuery?.run(Date.now() - 3_600_000)
+      this.#database?.exec('PRAGMA wal_checkpoint(TRUNCATE)')
       this.#database?.exec('PRAGMA optimize')
     } catch (err) {
       this.#emitError(err         )
@@ -413,12 +416,6 @@ export class Cache                                              extends EventEmi
       if (now >= cached.stale) {
         // stale-while-revalidate has expired, purge cached value.
         this.#memory?.delete(key)
-        try {
-          this.#delQuery?.run(key)
-        } catch {
-          // Do nothing...
-        }
-
         cached = undefined
       }
     }
@@ -428,6 +425,13 @@ export class Cache                                              extends EventEmi
       return { value: cached?.value, async: false }
     }
 
+    {
+      const pending = this.#dedupe.get(key)
+      if (pending !== undefined) {
+        return { async: true, value: pending }
+      }
+    }
+
     let result                
     try {
       result = this.#refresh(args, key)
@@ -451,11 +455,6 @@ export class Cache                                              extends EventEmi
       throw new TypeError('keySelector must return a non-empty string')
     }
 
-    const existing = this.#dedupe.get(key)
-    if (existing !== undefined) {
-      return { async: true, value: existing }
-    }
-
     if (this.#lockTimeout >= 0) {
       // Another process holds the lock — wait for the value instead of calling valueSelector.
       // Use deferred pattern so #waitForValue can check promise identity to detect delete+get races.
@@ -521,7 +520,9 @@ export class Cache                                              extends EventEmi
     this.#dedupe.delete(key)
 
     if (value === undefined) {
+      // Slow path... Should not be common...
       this.#memory?.delete(key)
+      this.#setBatch = this.#setBatch.filter((item) => item.key !== key)
       try {
         this.#delQuery?.run(key)
       } catch (err) {
@@ -549,7 +550,6 @@ export class Cache                                              extends EventEmi
     }
 
     const data = this.#serializer.serialize(value)
-
     const entry = this.#createEntry(
       key,
       value,
@@ -559,19 +559,74 @@ export class Cache                                              extends EventEmi
     )
     this.#memory?.set(key, entry)
 
+    if (this.#setBatch.length === 0) {
+      this.#memory?.cork()
+      setImmediate(this.#flush)
+    }
+
+    this.#setBatch.push({ key, data, ttl, stale })
+  }
+
+  #flush = () => {
+    if (this.#setBatch.length === 0 || this.#closed || this.#database == null) {
+      this.#setBatch.length = 0
+      this.#memory?.uncork()
+      return
+    }
+
     try {
-      this.#setQuery?.run(key, data                 , ttl, stale)
-    } 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.#setQuery?.run(key, data                 , ttl, stale)
-        } catch (evictErr) {
-          this.#emitError(evictErr         )
+          this.#database.exec('BEGIN')
+          while (n < this.#setBatch.length) {
+            const { key, data, ttl, stale } = this.#setBatch[n++]
+            if (data != null) {
+              this.#setQuery?.run(key, data, ttl, stale)
+            } else {
+              this.#delQuery?.run(key)
+            }
+            if ((n & 0xf) === 0 && performance.now() - startTime > 10) {
+              break
+            }
+          }
+          this.#database.exec('COMMIT')
+          this.#setBatch.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.#database.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 != null
+          ) {
+            this.#evictQuery.run(256)
+          } else {
+            this.#setBatch.splice(0, n)
+            throw err
+          }
         }
-      } else {
-        this.#emitError(err         )
       }
+    } catch (err) {
+      this.#emitError(err         )
+    }
+
+    if (this.#setBatch.length > 0) {
+      // If we weren't able to flush the entire batch within the time limit, schedule another flush.
+      setImmediate(this.#flush)
+    } else {
+      this.#memory?.uncork()
     }
   }
 

package/lib/memory.d.ts

@@ -15,6 +15,8 @@ export declare class MemoryCache<V> {
     #private;
     constructor(opts?: MemoryOptions);
     set(key: string, entry: MemoryCacheEntry<V>): void;
+    cork(): void;
+    uncork(): void;
     get(key: string): MemoryCacheEntry<V> | undefined;
     delete(key: string): void;
     purgeStale(now: number): void;

package/lib/memory.js

@@ -26,6 +26,7 @@ export class MemoryCache    {
   #count = 0
 
   #counter = 0
+  #cork = 0
 
   constructor(opts                ) {
     if (opts?.maxSize != null && (!Number.isInteger(opts.maxSize) || opts.maxSize < 1)) {
@@ -59,6 +60,19 @@ export class MemoryCache    {
     this.#prune()
   }
 
+  cork() {
+    this.#cork += 1
+  }
+
+  uncork() {
+    if (this.#cork > 0) {
+      this.#cork -= 1
+      if (this.#cork === 0) {
+        this.#prune()
+      }
+    }
+  }
+
   get(key        ) {
     const entry = this.#map.get(key)
     if (entry != null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/cache",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -30,5 +30,5 @@
     "tsd": "^0.33.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "f0aff304c4a0a7246ea0cb34f8d8b3839dc11e81"
+  "gitHead": "f7c04358e008a7b0f28e2ca76a81ebdc07fbd734"
 }