@unicitylabs/sphere-sdk 0.4.0 → 0.4.3

package/dist/impl/browser/index.cjs

@@ -435,28 +435,38 @@ var IndexedDBStorageProvider = class {
   // ===========================================================================
   async connect() {
     if (this.status === "connected" && this.db) return;
-    this.status = "connecting";
-    try {
-      this.db = await Promise.race([
-        this.openDatabase(),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("IndexedDB open timed out after 5s")), 5e3)
-        )
-      ]);
-      this.status = "connected";
-      this.log("Connected to IndexedDB");
-    } catch (error) {
-      this.status = "error";
-      throw new Error(`IndexedDB not available: ${error}`);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      this.status = "connecting";
+      console.log(`[IndexedDBStorage] connect: opening db=${this.dbName}${attempt > 0 ? " (retry)" : ""}`);
+      try {
+        this.db = await Promise.race([
+          this.openDatabase(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("IndexedDB open timed out after 5s")), 5e3)
+          )
+        ]);
+        this.status = "connected";
+        console.log(`[IndexedDBStorage] connect: connected to db=${this.dbName}`);
+        return;
+      } catch (error) {
+        if (attempt === 0) {
+          console.warn(`[IndexedDBStorage] connect: open failed, retrying in 1s...`);
+          this.status = "disconnected";
+          await new Promise((r) => setTimeout(r, 1e3));
+          continue;
+        }
+        this.status = "error";
+        throw new Error(`IndexedDB not available: ${error}`);
+      }
     }
   }
   async disconnect() {
+    console.log(`[IndexedDBStorage] disconnect: closing db=${this.dbName}, wasConnected=${!!this.db}`);
     if (this.db) {
       this.db.close();
       this.db = null;
     }
     this.status = "disconnected";
-    this.log("Disconnected from IndexedDB");
   }
   isConnected() {
     return this.status === "connected" && this.db !== null;
@@ -508,6 +518,7 @@ var IndexedDBStorageProvider = class {
   }
   async clear(prefix) {
     if (!prefix) {
+      console.log(`[IndexedDBStorage] clear: starting, db=${this.dbName}, wasConnected=${!!this.db}`);
       if (this.db) {
         this.db.close();
         this.db = null;
@@ -516,9 +527,23 @@ var IndexedDBStorageProvider = class {
       await new Promise((resolve) => {
         try {
           const req = indexedDB.deleteDatabase(this.dbName);
-          req.onsuccess = () => resolve();
-          req.onerror = () => resolve();
-          req.onblocked = () => resolve();
+          const timer = setTimeout(() => {
+            console.warn(`[IndexedDBStorage] clear: deleteDatabase timed out for db=${this.dbName}`);
+            resolve();
+          }, 5e3);
+          req.onsuccess = () => {
+            clearTimeout(timer);
+            console.log(`[IndexedDBStorage] clear: deleted db=${this.dbName}`);
+            resolve();
+          };
+          req.onerror = () => {
+            clearTimeout(timer);
+            console.warn(`[IndexedDBStorage] clear: error deleting db=${this.dbName}`, req.error);
+            resolve();
+          };
+          req.onblocked = () => {
+            console.warn(`[IndexedDBStorage] clear: deleteDatabase blocked for db=${this.dbName}, waiting...`);
+          };
         } catch {
           resolve();
         }
@@ -689,12 +714,19 @@ var IndexedDBTokenStorageProvider = class {
       const addressId = getAddressId(identity.directAddress);
       this.dbName = `${this.dbNamePrefix}-${addressId}`;
     }
+    console.log(`[IndexedDBTokenStorage] setIdentity \u2192 db=${this.dbName}`);
   }
   async initialize() {
     try {
+      if (this.db) {
+        console.log(`[IndexedDBTokenStorage] initialize: closing existing connection before re-open (db=${this.dbName})`);
+        this.db.close();
+        this.db = null;
+      }
+      console.log(`[IndexedDBTokenStorage] initialize: opening db=${this.dbName}`);
       this.db = await this.openDatabase();
       this.status = "connected";
-      this.cleanupStaleDatabases();
+      console.log(`[IndexedDBTokenStorage] initialize: connected to db=${this.dbName}`);
       return true;
     } catch (error) {
       console.error("[IndexedDBTokenStorage] Failed to initialize:", error);
@@ -703,6 +735,7 @@ var IndexedDBTokenStorageProvider = class {
     }
   }
   async shutdown() {
+    console.log(`[IndexedDBTokenStorage] shutdown: closing db=${this.dbName}, wasConnected=${!!this.db}`);
     if (this.db) {
       this.db.close();
       this.db = null;
@@ -723,6 +756,7 @@ var IndexedDBTokenStorageProvider = class {
   }
   async load() {
     if (!this.db) {
+      console.warn(`[IndexedDBTokenStorage] load: db not initialized (db=${this.dbName})`);
       return {
         success: false,
         error: "Database not initialized",
@@ -771,6 +805,8 @@ var IndexedDBTokenStorageProvider = class {
       if (invalid) {
         data._invalid = invalid;
       }
+      const tokenKeys = Object.keys(data).filter((k) => k.startsWith("_") && !["_meta", "_tombstones", "_outbox", "_sent", "_invalid"].includes(k));
+      console.log(`[IndexedDBTokenStorage] load: db=${this.dbName}, tokens=${tokenKeys.length}`);
       return {
         success: true,
         data,
@@ -778,6 +814,7 @@ var IndexedDBTokenStorageProvider = class {
         timestamp: Date.now()
       };
     } catch (error) {
+      console.error(`[IndexedDBTokenStorage] load failed: db=${this.dbName}`, error);
       return {
         success: false,
         error: error instanceof Error ? error.message : "Unknown error",
@@ -788,6 +825,7 @@ var IndexedDBTokenStorageProvider = class {
   }
   async save(data) {
     if (!this.db) {
+      console.warn(`[IndexedDBTokenStorage] save: db not initialized (db=${this.dbName})`);
       return {
         success: false,
         error: "Database not initialized",
@@ -795,6 +833,9 @@ var IndexedDBTokenStorageProvider = class {
       };
     }
     try {
+      const tokenKeys = Object.keys(data).filter((k) => k.startsWith("_") && !["_meta", "_tombstones", "_outbox", "_sent", "_invalid"].includes(k));
+      const archivedKeys = Object.keys(data).filter((k) => k.startsWith("archived-"));
+      console.log(`[IndexedDBTokenStorage] save: db=${this.dbName}, tokens=${tokenKeys.length}, archived=${archivedKeys.length}, tombstones=${data._tombstones?.length ?? 0}`);
       await this.putToStore(STORE_META, "meta", data._meta);
       if (data._tombstones) {
         await this.putToStore(STORE_META, "tombstones", data._tombstones);
@@ -853,6 +894,7 @@ var IndexedDBTokenStorageProvider = class {
   }
   async clear() {
     try {
+      console.log(`[IndexedDBTokenStorage] clear: starting, db=${this.dbName}, wasConnected=${!!this.db}`);
       if (this.db) {
         this.db.close();
         this.db = null;
@@ -875,13 +917,21 @@ var IndexedDBTokenStorageProvider = class {
         } catch {
         }
       }
+      console.log(`[IndexedDBTokenStorage] clear: deleting ${dbNames.length} database(s):`, dbNames);
       await Promise.all(dbNames.map(
         (name) => new Promise((resolve) => {
           try {
             const req = indexedDB.deleteDatabase(name);
-            req.onsuccess = () => resolve();
-            req.onerror = () => resolve();
+            req.onsuccess = () => {
+              console.log(`[IndexedDBTokenStorage] clear: deleted db=${name}`);
+              resolve();
+            };
+            req.onerror = () => {
+              console.warn(`[IndexedDBTokenStorage] clear: error deleting db=${name}`, req.error);
+              resolve();
+            };
             req.onblocked = () => {
+              console.warn(`[IndexedDBTokenStorage] clear: deleteDatabase blocked for db=${name}`);
               resolve();
             };
           } catch {
@@ -889,6 +939,7 @@ var IndexedDBTokenStorageProvider = class {
           }
         })
       ));
+      console.log(`[IndexedDBTokenStorage] clear: done`);
       return true;
     } catch (err) {
       console.warn("[IndexedDBTokenStorage] clear() failed:", err);
@@ -898,26 +949,6 @@ var IndexedDBTokenStorageProvider = class {
   // =========================================================================
   // Private IndexedDB helpers
   // =========================================================================
-  /**
-   * Delete stale databases from other addresses (fire-and-forget, background).
-   * Called after the current database is already open, so deleteDatabase
-   * on other databases won't block anything.
-   */
-  cleanupStaleDatabases() {
-    if (typeof indexedDB.databases !== "function") return;
-    indexedDB.databases().then((dbs) => {
-      for (const dbInfo of dbs) {
-        if (dbInfo.name && dbInfo.name.startsWith(this.dbNamePrefix) && dbInfo.name !== this.dbName) {
-          const req = indexedDB.deleteDatabase(dbInfo.name);
-          req.onerror = () => {
-          };
-          req.onblocked = () => {
-          };
-        }
-      }
-    }).catch(() => {
-    });
-  }
   openDatabase() {
     return new Promise((resolve, reject) => {
       const request = indexedDB.open(this.dbName, DB_VERSION2);