@nxtedition/lib 26.0.6 → 26.0.8

package/cache.js

@@ -1,7 +1,11 @@
+import { DatabaseSync } from 'node:sqlite'
 import { LRUCache } from 'lru-cache'
+import { fastNow } from './time.js'
+
+function noop() {}
 
 export class AsyncCache {
-  /** @type LRUCache<string, { expire: Number, value: any } **/
+  /** @type LRUCache<string, { ttl: number, stale: number, value: any } **/
   #lru
   #valueSelector
   #keySelector
@@ -9,9 +13,12 @@ export class AsyncCache {
   #ttl
   #stale
 
-  constructor(location, valueSelector, keySelector, opts) {
-    this.#lru = new LRUCache({ max: 4096 })
+  #db
+  #getQuery
+  #setQuery
+  #delQuery
 
+  constructor(location, valueSelector, keySelector, opts) {
     if (typeof location === 'string') {
       // Do nothing...
     } else {
@@ -47,6 +54,33 @@ export class AsyncCache {
     } else {
       throw new TypeError('stale must be a undefined, number or a function')
     }
+
+    this.#lru =
+      opts?.lru === false || opts?.lru === null ? null : new LRUCache({ max: 4096, ...opts?.lru })
+    this.#db = new DatabaseSync(location, { timeout: 20, ...opts?.db })
+    this.#db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA temp_store = memory;
+      PRAGMA optimize;
+
+      CREATE TABLE IF NOT EXISTS cache (
+        key TEXT PRIMARY KEY NOT NULL,
+        val TEXT NOT NULL,
+        ttl INTEGER NOT NULL,
+        stale INTEGER NOT NULL
+      );
+    `)
+
+    this.#getQuery = this.#db.prepare(`SELECT val, ttl, stale FROM cache WHERE key = ?`)
+    this.#setQuery = this.#db.prepare(
+      `INSERT OR REPLACE INTO cache (key, val, ttl, stale) VALUES (?, ?, ?, ?)`,
+    )
+    this.#delQuery = this.#db.prepare(`DELETE FROM cache WHERE key = ?`)
+  }
+
+  close() {
+    this.#db?.close()
   }
 
   /**
@@ -60,54 +94,66 @@ export class AsyncCache {
       throw new TypeError('keySelector must return a non-empty string')
     }
 
-    let cached = this.#lru.get(key)
+    const now = fastNow()
+
+    let cached = this.#lru?.get(key)
 
-    if (cached) {
-      const now = Date.now()
+    if (cached === undefined) {
+      try {
+        const ret = this.#getQuery?.get(key)
+        if (ret !== undefined) {
+          cached = {
+            ttl: ret.ttl,
+            stale: ret.stale,
+            value: JSON.parse(ret.val),
+          }
+          this.#lru?.set(key, cached)
+        }
+      } catch {
+        // Do nothing...
+      }
+    }
 
-      if (now < cached.expire) {
+    if (cached !== undefined) {
+      if (now < cached.ttl) {
         return { value: cached.value, async: false }
       }
 
-      if (now - cached.expire >= this.#stale(cached.value, key)) {
-        // stale-while-revalidate has also expired, dont use cached value
-        cached = null
+      if (now > cached.stale) {
+        // stale-while-revalidate has ttld, purge cached value.
+        this.#lru?.delete(key)
+        try {
+          this.#delQuery?.run(key)
+        } catch {
+          // Do nothing...
+        }
+
+        cached = undefined
       }
     }
 
     let promise
-
     if (this.#valueSelector) {
       promise = this.#dedupe.get(key)
-      if (!promise) {
+      if (promise === undefined) {
         promise = this.#valueSelector(...args).then(
           (value) => {
             this.set(key, value)
-            return [null, value]
+            return value
           },
           (err) => {
             this.delete(key)
-            return [err, null]
+            throw err
           },
         )
+        promise.catch(noop)
         this.#dedupe.set(key, promise)
       }
     }
 
-    if (cached) {
-      return { value: cached.value, async: false }
-    }
-
-    return {
-      value: promise.then(([err, val]) => {
-        if (err) {
-          throw err
-        }
-
-        return val
-      }),
-      async: true,
-    }
+    return cached !== undefined
+      ? { value: cached.value, async: false }
+      : { value: promise, async: true }
   }
 
   /**
@@ -119,28 +165,34 @@ export class AsyncCache {
       throw new TypeError('key must be a non-empty string')
     }
 
+    const now = fastNow()
     const cached = {
-      expire: Date.now() + this.#ttl(value, key),
+      ttl: now + this.#ttl(value, key),
+      stale: now + this.#stale(value, key),
       value,
     }
 
-    this.#lru.set(key, cached)
+    this.#lru?.set(key, cached)
     this.#dedupe.delete(key)
+
+    try {
+      this.#setQuery?.run(key, JSON.stringify(value), cached.ttl, cached.stale)
+    } catch {
+      // Do nothing...
+    }
   }
 
-  /**
-   * @param {string} key
-   */
   delete(key) {
     if (typeof key !== 'string' || key.length === 0) {
       throw new TypeError('key must be a non-empty string')
     }
 
-    this.#lru.delete(key)
-    this.#dedupe.delete(key)
-  }
+    this.#lru?.delete(key)
 
-  clear() {
-    // TODO (fix): Implement...
+    try {
+      this.#delQuery?.run(key)
+    } catch {
+      // Do nothing...
+    }
   }
 }

package/http.js

@@ -166,7 +166,9 @@ export async function upgradeMiddleware(ctx, next) {
       await thenable
     }
 
-    assert(socket.destroyed || socket.writableEnded, 'stream not completed')
+    if (!socket.destroyed && !socket.writableEnded) {
+      throw new Error('Stream not completed')
+    }
 
     const elapsedTime = performance.now() - startTime
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "26.0.6",
+  "version": "26.0.8",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",