@fairfox/polly 0.61.0 → 0.62.0

package/dist/src/shared/lib/idb-helpers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Tiny internal helpers around the raw IndexedDB API.
+ *
+ * Wraps the patterns that `storage-adapter.ts` and `blob-cache.ts` both
+ * re-implement: timed open with retry-on-failure caching, request→promise
+ * wrapping, transaction-to-completion, and cursor iteration. Not exported
+ * from the public package — internal to `src/shared/lib`.
+ */
+/** Polly#107 post-v0.60: hard timeout on `indexedDB.open()`. Healthy
+ *  opens land in microseconds; the v0.60.0 fingerprint surfaced a zombie
+ *  cross-tab connection that left an open request firing no events at all.
+ *  5s is two orders of magnitude beyond the normal upper bound and short
+ *  enough that the operator gets a named failure instead of a hung page
+ *  when the storage layer wedges. */
+export declare const IDB_OPEN_TIMEOUT_MS = 5000;
+export interface OpenIDBOptions {
+    name: string;
+    version: number;
+    /** Invoked inside `onupgradeneeded`. Create object stores here. */
+    upgrade: (db: IDBDatabase, event: IDBVersionChangeEvent) => void;
+}
+/** Open an IndexedDB database with the Polly#107 timeout guard. */
+export declare function openIDB(options: OpenIDBOptions): Promise<IDBDatabase>;
+/** One-shot open caching with retry-on-failure. Caller owns a `{ promise }`
+ *  cell; first call opens, subsequent calls return the cached promise, and
+ *  a rejected open clears the cache so the next call can retry instead of
+ *  being poisoned by one transient failure. */
+export declare function cachedOpen(ref: {
+    promise: Promise<IDBDatabase> | null;
+}, options: OpenIDBOptions): Promise<IDBDatabase>;
+/** Promise-wrap a single `IDBRequest` (`get`, `put`, `count`, `delete`…). */
+export declare function runRequest<T>(request: IDBRequest<T>): Promise<T>;
+/** Run a transaction to completion. Resolves on `tx.oncomplete` (write
+ *  durability), not on individual request success. Throws inside `fn`
+ *  abort the transaction and reject. */
+export declare function runTx(db: IDBDatabase, storeName: string, mode: IDBTransactionMode, fn: (store: IDBObjectStore) => void): Promise<void>;
+/** Walk every record in a store. */
+export declare function iterateCursor<V>(db: IDBDatabase, storeName: string, visit: (key: IDBValidKey, value: V) => void): Promise<void>;

package/dist/src/shared/lib/message-bus.js

@@ -69,6 +69,90 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/shared/lib/idb-helpers.ts
+function openIDB(options) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const request = indexedDB.open(options.name, options.version);
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      const elapsedMs = Date.now() - start;
+      reject(new Error(`Polly IndexedDB open of '${options.name}' timed out after ${elapsedMs}ms (cross-tab lock or zombie connection?)`));
+    }, IDB_OPEN_TIMEOUT_MS);
+    request.onerror = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      reject(request.error);
+    };
+    request.onsuccess = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(request.result);
+    };
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      options.upgrade(db, event);
+    };
+  });
+}
+function cachedOpen(ref, options) {
+  if (ref.promise)
+    return ref.promise;
+  const pending = openIDB(options);
+  pending.catch(() => {
+    if (ref.promise === pending)
+      ref.promise = null;
+  });
+  ref.promise = pending;
+  return pending;
+}
+function runRequest(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function runTx(db, storeName, mode, fn) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, mode);
+    const store = tx.objectStore(storeName);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+    try {
+      fn(store);
+    } catch (err) {
+      try {
+        tx.abort();
+      } catch {}
+      reject(err);
+    }
+  });
+}
+function iterateCursor(db, storeName, visit) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, "readonly");
+    const store = tx.objectStore(storeName);
+    const request = store.openCursor();
+    request.onsuccess = () => {
+      const cursor = request.result;
+      if (!cursor)
+        return resolve();
+      visit(cursor.key, cursor.value);
+      cursor.continue();
+    };
+    request.onerror = () => reject(request.error);
+  });
+}
+var IDB_OPEN_TIMEOUT_MS = 5000;
+
 // src/shared/lib/storage-adapter.ts
 var exports_storage_adapter = {};
 __export(exports_storage_adapter, {
@@ -81,68 +165,32 @@ __export(exports_storage_adapter, {
 class IndexedDBAdapter {
   dbName;
   storeName = "state";
-  dbPromise = null;
+  dbRef = { promise: null };
   constructor(dbName = "polly-state") {
     this.dbName = dbName;
   }
   getDB() {
-    if (this.dbPromise)
-      return this.dbPromise;
-    const pending = new Promise((resolve, reject) => {
-      const start = Date.now();
-      const request = indexedDB.open(this.dbName, 1);
-      let settled = false;
-      const timer = setTimeout(() => {
-        if (settled)
-          return;
-        settled = true;
-        const elapsedMs = Date.now() - start;
-        reject(new Error(`Polly IndexedDB open of '${this.dbName}' timed out after ${elapsedMs}ms (cross-tab lock or zombie connection?)`));
-      }, IDB_OPEN_TIMEOUT_MS);
-      request.onerror = () => {
-        if (settled)
-          return;
-        settled = true;
-        clearTimeout(timer);
-        reject(request.error);
-      };
-      request.onsuccess = () => {
-        if (settled)
-          return;
-        settled = true;
-        clearTimeout(timer);
-        resolve(request.result);
-      };
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
+    return cachedOpen(this.dbRef, {
+      name: this.dbName,
+      version: 1,
+      upgrade: (db) => {
         if (!db.objectStoreNames.contains(this.storeName)) {
           db.createObjectStore(this.storeName);
         }
-      };
-    });
-    pending.catch(() => {
-      if (this.dbPromise === pending)
-        this.dbPromise = null;
+      }
     });
-    this.dbPromise = pending;
-    return pending;
   }
   async get(keys) {
     try {
       const db = await this.getDB();
+      const tx = db.transaction(this.storeName, "readonly");
+      const store = tx.objectStore(this.storeName);
+      const pairs = await Promise.all(keys.map(async (key) => [key, await runRequest(store.get(key))]));
       const result = {};
-      await Promise.all(keys.map((key) => new Promise((resolve, reject) => {
-        const transaction = db.transaction([this.storeName], "readonly");
-        const store = transaction.objectStore(this.storeName);
-        const request = store.get(key);
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => {
-          if (request.result !== undefined) {
-            result[key] = request.result;
-          }
-          resolve();
-        };
-      })));
+      for (const [key, value] of pairs) {
+        if (value !== undefined)
+          result[key] = value;
+      }
       return result;
     } catch (error) {
       console.warn("[Polly] IndexedDB get failed:", error);
@@ -152,13 +200,11 @@ class IndexedDBAdapter {
   async set(items) {
     try {
       const db = await this.getDB();
-      await Promise.all(Object.entries(items).map(([key, value]) => new Promise((resolve, reject) => {
-        const transaction = db.transaction([this.storeName], "readwrite");
-        const store = transaction.objectStore(this.storeName);
-        const request = store.put(value, key);
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => resolve();
-      })));
+      await runTx(db, this.storeName, "readwrite", (store) => {
+        for (const [key, value] of Object.entries(items)) {
+          store.put(value, key);
+        }
+      });
     } catch (error) {
       console.warn("[Polly] IndexedDB set failed:", error);
     }
@@ -166,13 +212,10 @@ class IndexedDBAdapter {
   async remove(keys) {
     try {
       const db = await this.getDB();
-      await Promise.all(keys.map((key) => new Promise((resolve, reject) => {
-        const transaction = db.transaction([this.storeName], "readwrite");
-        const store = transaction.objectStore(this.storeName);
-        const request = store.delete(key);
-        request.onerror = () => reject(request.error);
-        request.onsuccess = () => resolve();
-      })));
+      await runTx(db, this.storeName, "readwrite", (store) => {
+        for (const key of keys)
+          store.delete(key);
+      });
     } catch (error) {
       console.warn("[Polly] IndexedDB remove failed:", error);
     }
@@ -245,7 +288,7 @@ function createStorageAdapter() {
   }
   return new MemoryStorageAdapter;
 }
-var IDB_OPEN_TIMEOUT_MS = 5000;
+var init_storage_adapter = () => {};
 
 // src/shared/lib/sync-adapter.ts
 var exports_sync_adapter = {};
@@ -749,6 +792,7 @@ class MessageLoggerAdapter {
 }
 
 // src/shared/lib/adapter-factory.ts
+init_storage_adapter();
 function createStateAdapters(options = {}) {
   if (options.storage && options.sync) {
     return {
@@ -769,7 +813,7 @@ function createStateAdapters(options = {}) {
   return { storage, sync };
 }
 function createChromeAdapters() {
-  const { ChromeStorageAdapter: ChromeStorageAdapter3 } = __toCommonJS(exports_storage_adapter);
+  const { ChromeStorageAdapter: ChromeStorageAdapter3 } = (init_storage_adapter(), __toCommonJS(exports_storage_adapter));
   const { ChromeRuntimeSyncAdapter: ChromeRuntimeSyncAdapter2 } = __toCommonJS(exports_sync_adapter);
   return {
     storage: new ChromeStorageAdapter3,
@@ -777,14 +821,14 @@ function createChromeAdapters() {
   };
 }
 function createWebAdapters(options = {}) {
-  const { IndexedDBAdapter: IndexedDBAdapter2 } = __toCommonJS(exports_storage_adapter);
+  const { IndexedDBAdapter: IndexedDBAdapter2 } = (init_storage_adapter(), __toCommonJS(exports_storage_adapter));
   const { BroadcastChannelSyncAdapter: BroadcastChannelSyncAdapter2, NoOpSyncAdapter: NoOpSyncAdapter2 } = __toCommonJS(exports_sync_adapter);
   const storage = new IndexedDBAdapter2(options.dbName);
   const sync = options.singleTab ? new NoOpSyncAdapter2 : new BroadcastChannelSyncAdapter2(options.channelName);
   return { storage, sync };
 }
 function createNodeAdapters() {
-  const { MemoryStorageAdapter: MemoryStorageAdapter2 } = __toCommonJS(exports_storage_adapter);
+  const { MemoryStorageAdapter: MemoryStorageAdapter2 } = (init_storage_adapter(), __toCommonJS(exports_storage_adapter));
   const { NoOpSyncAdapter: NoOpSyncAdapter2 } = __toCommonJS(exports_sync_adapter);
   return {
     storage: new MemoryStorageAdapter2,
@@ -792,7 +836,7 @@ function createNodeAdapters() {
   };
 }
 function createMockAdapters() {
-  const { MemoryStorageAdapter: MemoryStorageAdapter2 } = __toCommonJS(exports_storage_adapter);
+  const { MemoryStorageAdapter: MemoryStorageAdapter2 } = (init_storage_adapter(), __toCommonJS(exports_storage_adapter));
   const { NoOpSyncAdapter: NoOpSyncAdapter2 } = __toCommonJS(exports_sync_adapter);
   return {
     storage: new MemoryStorageAdapter2,
@@ -801,6 +845,7 @@ function createMockAdapters() {
 }
 
 // src/shared/adapters/index.ts
+init_storage_adapter();
 function createChromeAdapters2(context, options) {
   const runtime2 = new ChromeRuntimeAdapter;
   return {
@@ -1590,4 +1635,4 @@ export {
   MessageBus
 };
 
-//# debugId=22215C731A04603464756E2164756E21
+//# debugId=3223EA30A6C6201E64756E2164756E21