@nxtedition/lib 26.0.7 → 26.0.9

package/cache.js

@@ -4,13 +4,29 @@ import { fastNow } from './time.js'
 
 function noop() {}
 
+/**
+ * @template [V=unknown]
+ * @typedef {object} AsyncCacheOptions
+ * @property {number | ((value: V, key: string) => number)} [ttl]
+ * @property {number | ((value: V, key: string) => number)} [stale]
+ * @property {import('lru-cache').LRUCache.Options<string, { ttl: number, stale: number, value: V }> | false | null} [lru]
+ * @property {{ timeout?: number }} [db]
+ */
+
+/**
+ * @template [V=unknown]
+ */
 export class AsyncCache {
-  /** @type LRUCache<string, { ttl: number, stale: number, value: any } **/
+  /** @type LRUCache<string, { ttl: number, stale: number, value: V }> */
   #lru
   #valueSelector
   #keySelector
   #dedupe = new Map()
+
+  /** @type {(val: V, key: string) => number} */
   #ttl
+
+  /** @type {(val: V, key: string) => number} */
   #stale
 
   #db
@@ -18,6 +34,12 @@ export class AsyncCache {
   #setQuery
   #delQuery
 
+  /**
+   * @param {string} location
+   * @param {((...args: any[]) => Promise<V>)|undefined} [valueSelector]
+   * @param {((...args: any[]) => string)|undefined} [keySelector]
+   * @param {AsyncCacheOptions<V>} [opts]
+   */
   constructor(location, valueSelector, keySelector, opts) {
     if (typeof location === 'string') {
       // Do nothing...
@@ -55,27 +77,38 @@ export class AsyncCache {
       throw new TypeError('stale must be a undefined, number or a function')
     }
 
-    this.#lru = 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 = ?`)
+    this.#lru =
+      opts?.lru === false || opts?.lru === null ? null : new LRUCache({ max: 4096, ...opts?.lru })
+
+    for (let n = 0; true; n += 1) {
+      try {
+        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 = ?`)
+      } catch (err) {
+        if (n > 128 || !/locked|busy/i.test(err?.message)) {
+          throw err
+        }
+      }
+    }
   }
 
   close() {
@@ -84,7 +117,7 @@ export class AsyncCache {
 
   /**
    * @param  {...any} args
-   * @returns {{ value: Promise<unknown>|unknown, async: boolean }}
+   * @returns {{ value: V|Promise<V>, async: boolean }}
    */
   get(...args) {
     const key = this.#keySelector(...args)
@@ -95,7 +128,7 @@ export class AsyncCache {
 
     const now = fastNow()
 
-    let cached = this.#lru.get(key)
+    let cached = this.#lru?.get(key)
 
     if (cached === undefined) {
       try {
@@ -106,7 +139,7 @@ export class AsyncCache {
             stale: ret.stale,
             value: JSON.parse(ret.val),
           }
-          this.#lru.set(key, cached)
+          this.#lru?.set(key, cached)
         }
       } catch {
         // Do nothing...
@@ -120,9 +153,9 @@ export class AsyncCache {
 
       if (now > cached.stale) {
         // stale-while-revalidate has ttld, purge cached value.
-        this.#lru.delete(key)
+        this.#lru?.delete(key)
         try {
-          this.#delQuery.run(key)
+          this.#delQuery?.run(key)
         } catch {
           // Do nothing...
         }
@@ -157,7 +190,7 @@ export class AsyncCache {
 
   /**
    * @param {string} key
-   * @param {any} value
+   * @param {V} value
    */
   set(key, value) {
     if (typeof key !== 'string' || key.length === 0) {
@@ -171,7 +204,7 @@ export class AsyncCache {
       value,
     }
 
-    this.#lru.set(key, cached)
+    this.#lru?.set(key, cached)
     this.#dedupe.delete(key)
 
     try {
@@ -180,4 +213,21 @@ export class AsyncCache {
       // 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)
+
+    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.7",
+  "version": "26.0.9",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",