Fixed:

- Databases now correctly closed after rebuilding.

src/common/KeyValueDB.ts

@@ -1,5 +1,7 @@
 import { deleteDB, type IDBPDatabase, openDB } from "idb";
 import type { KeyValueDatabase } from "../lib/src/interfaces/KeyValueDatabase.ts";
+import { serialized } from "octagonal-wheels/concurrency/lock";
+import { Logger } from "octagonal-wheels/common/logger";
 const databaseCache: { [key: string]: IDBPDatabase<any> } = {};
 export const OpenKeyValueDatabase = async (dbKey: string): Promise<KeyValueDatabase> => {
     if (dbKey in databaseCache) {
@@ -7,37 +9,89 @@ export const OpenKeyValueDatabase = async (dbKey: string): Promise<KeyValueDatab
         delete databaseCache[dbKey];
     }
     const storeKey = dbKey;
-    const dbPromise = openDB(dbKey, 1, {
-        upgrade(db, _oldVersion, _newVersion, _transaction, _event) {
-            return db.createObjectStore(storeKey);
-        },
-    });
-    const db = await dbPromise;
-    databaseCache[dbKey] = db;
+    let db: IDBPDatabase<any> | null = null;
+    const _openDB = () => {
+        return serialized("keyvaluedb-" + dbKey, async () => {
+            const dbInstance = await openDB(dbKey, 1, {
+                upgrade(db, _oldVersion, _newVersion, _transaction, _event) {
+                    return db.createObjectStore(storeKey);
+                },
+                blocking(currentVersion, blockedVersion, event) {
+                    Logger(
+                        `Blocking database open for ${dbKey}: currentVersion=${currentVersion}, blockedVersion=${blockedVersion}`
+                    );
+                    databaseCache[dbKey]?.close();
+                    delete databaseCache[dbKey];
+                },
+                blocked(currentVersion, blockedVersion, event) {
+                    Logger(
+                        `Database open blocked for ${dbKey}: currentVersion=${currentVersion}, blockedVersion=${blockedVersion}`
+                    );
+                },
+                terminated() {
+                    Logger(`Database connection terminated for ${dbKey}`);
+                },
+            });
+            databaseCache[dbKey] = dbInstance;
+            return dbInstance;
+        });
+    };
+    const closeDB = () => {
+        if (db) {
+            db.close();
+            delete databaseCache[dbKey];
+            db = null;
+        }
+    };
+    db = await _openDB();
     return {
         async get<T>(key: IDBValidKey): Promise<T> {
+            if (!db) {
+                db = await _openDB();
+                databaseCache[dbKey] = db;
+            }
             return await db.get(storeKey, key);
         },
         async set<T>(key: IDBValidKey, value: T) {
+            if (!db) {
+                db = await _openDB();
+                databaseCache[dbKey] = db;
+            }
             return await db.put(storeKey, value, key);
         },
         async del(key: IDBValidKey) {
+            if (!db) {
+                db = await _openDB();
+                databaseCache[dbKey] = db;
+            }
             return await db.delete(storeKey, key);
         },
         async clear() {
+            if (!db) {
+                db = await _openDB();
+                databaseCache[dbKey] = db;
+            }
             return await db.clear(storeKey);
         },
         async keys(query?: IDBValidKey | IDBKeyRange, count?: number) {
+            if (!db) {
+                db = await _openDB();
+                databaseCache[dbKey] = db;
+            }
             return await db.getAllKeys(storeKey, query, count);
         },
         close() {
             delete databaseCache[dbKey];
-            return db.close();
+            return closeDB();
         },
         async destroy() {
             delete databaseCache[dbKey];
-            db.close();
-            await deleteDB(dbKey);
+            // await closeDB();
+            await deleteDB(dbKey, {
+                blocked() {
+                    console.warn(`Database delete blocked for ${dbKey}`);
+                },
+            });
         },
     };
 };