@unicitylabs/sphere-sdk 0.4.0 → 0.4.2

package/dist/impl/browser/index.js

@@ -376,6 +376,7 @@ var IndexedDBStorageProvider = class {
   async connect() {
     if (this.status === "connected" && this.db) return;
     this.status = "connecting";
+    console.log(`[IndexedDBStorage] connect: opening db=${this.dbName}`);
     try {
       this.db = await Promise.race([
         this.openDatabase(),
@@ -384,19 +385,19 @@ var IndexedDBStorageProvider = class {
         )
       ]);
       this.status = "connected";
-      this.log("Connected to IndexedDB");
+      console.log(`[IndexedDBStorage] connect: connected to db=${this.dbName}`);
     } catch (error) {
       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;
@@ -448,6 +449,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;
@@ -456,9 +458,18 @@ var IndexedDBStorageProvider = class {
       await new Promise((resolve) => {
         try {
           const req = indexedDB.deleteDatabase(this.dbName);
-          req.onsuccess = () => resolve();
-          req.onerror = () => resolve();
-          req.onblocked = () => resolve();
+          req.onsuccess = () => {
+            console.log(`[IndexedDBStorage] clear: deleted db=${this.dbName}`);
+            resolve();
+          };
+          req.onerror = () => {
+            console.warn(`[IndexedDBStorage] clear: error deleting db=${this.dbName}`, req.error);
+            resolve();
+          };
+          req.onblocked = () => {
+            console.warn(`[IndexedDBStorage] clear: deleteDatabase blocked for db=${this.dbName}`);
+            resolve();
+          };
         } catch {
           resolve();
         }
@@ -629,12 +640,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);
@@ -643,6 +661,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;
@@ -663,6 +682,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",
@@ -711,6 +731,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,
@@ -718,6 +740,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",
@@ -728,6 +751,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",
@@ -735,6 +759,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);
@@ -793,6 +820,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;
@@ -815,13 +843,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 {
@@ -829,6 +865,7 @@ var IndexedDBTokenStorageProvider = class {
           }
         })
       ));
+      console.log(`[IndexedDBTokenStorage] clear: done`);
       return true;
     } catch (err) {
       console.warn("[IndexedDBTokenStorage] clear() failed:", err);
@@ -838,26 +875,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);