@nxtedition/lib 26.0.11 → 26.0.14

package/cache.js

@@ -80,37 +80,43 @@ export class AsyncCache {
     this.#lru =
       opts?.lru === false || opts?.lru === null ? null : new LRUCache({ max: 4096, ...opts?.lru })
 
-    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) {
-      this.#db?.close()
-      this.#db = null
-
-      this.#getQuery = null
-      this.#setQuery = null
-      this.#delQuery = null
-
-      process.emitWarning(err)
+    for (let n = 0; true; n++) {
+      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 = ?`)
+        break
+      } catch (err) {
+        if (n >= 8) {
+          this.#db?.close()
+          this.#db = null
+
+          this.#getQuery = null
+          this.#setQuery = null
+          this.#delQuery = null
+
+          process.emitWarning(err)
+          break
+        }
+      }
     }
   }
 
@@ -123,6 +129,31 @@ export class AsyncCache {
    * @returns {{ value: V|Promise<V>, async: boolean }}
    */
   get(...args) {
+    return this.#load(args, true)
+  }
+
+  /**
+   * @param  {...any} args
+   * @returns {{ value: V|Promise<V>, async: boolean }}
+   */
+  peek(...args) {
+    return this.#load(args, false)
+  }
+
+  /**
+   * @param  {...any} args
+   * @returns {Promise<V>}
+   */
+  refresh(...args) {
+    return this.#refresh(args)
+  }
+
+  /**
+   * @param  {any[]} args
+   * @param  {boolean} refresh
+   * @returns {{ value: V|Promise<V>, async: boolean }}
+   */
+  #load(args, refresh) {
     const key = this.#keySelector(...args)
 
     if (typeof key !== 'string' || key.length === 0) {
@@ -167,30 +198,37 @@ export class AsyncCache {
       }
     }
 
-    let promise
-    if (this.#valueSelector) {
-      promise = this.#dedupe.get(key)
-      if (promise === undefined) {
-        promise = this.#valueSelector(...args).then(
-          (value) => {
-            this.set(key, value)
-            return value
-          },
-          (err) => {
-            this.delete(key)
-            throw err
-          },
-        )
-        promise.catch(noop)
-        this.#dedupe.set(key, promise)
-      }
-    }
+    const promise = refresh ? this.#refresh(args, key) : null
 
     return cached !== undefined
       ? { value: cached.value, async: false }
       : { value: promise, async: true }
   }
 
+  #refresh(args, key = this.#keySelector(...args)) {
+    if (typeof key !== 'string' || key.length === 0) {
+      throw new TypeError('keySelector must return a non-empty string')
+    }
+
+    let promise = this.#dedupe.get(key)
+    if (promise === undefined && this.#valueSelector) {
+      promise = this.#valueSelector(...args).then(
+        (value) => {
+          this.set(key, value)
+          return value
+        },
+        (err) => {
+          this.delete(key)
+          throw err
+        },
+      )
+      promise.catch(noop)
+      this.#dedupe.set(key, promise)
+    }
+
+    return promise
+  }
+
   /**
    * @param {string} key
    * @param {V} value

package/package.json

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

package/util/template/javascript.js

@@ -71,12 +71,15 @@ class FetchEntry {
         })
         .catch((err) => {
           if (this.refresh) {
-            this.error = Object.assign(err, { data: resource })
+            this.error = Object.assign(new Error('fetch failed'), {
+              data: { resource },
+              cause: err,
+            })
             this.refresh()
           }
         })
     } catch (err) {
-      this.error = Object.assign(err, { data: resource })
+      this.error = Object.assign(new Error('fetch failed'), { data: { resource }, cause: err })
       this.refresh()
     }
   }