web_lib

store.ts (5311B)

---

 import { RADROOTS_IDB_DATABASE, RADROOTS_IDB_STORES } from "./config.js";
 
 const log_idb = (label: string, payload?: Record<string, unknown>): void => {
     console.log(`[idb] ${label}`, payload ?? {});
 };
 
 const RADROOTS_IDB_STORE_SET = new Set(RADROOTS_IDB_STORES);
 const IDB_BOOTSTRAP_PROMISES = new Map<string, Promise<void>>();
 
 const idb_missing_stores = (db: IDBDatabase, stores: string[]): string[] =>
     stores.filter((store) => !db.objectStoreNames.contains(store));
 
 const idb_database_exists = async (database: string): Promise<boolean> => {
     if (typeof indexedDB === "undefined") return false;
     const list_fn = indexedDB.databases;
     if (typeof list_fn !== "function") return true;
     try {
         const entries = await list_fn.call(indexedDB);
         return entries.some((entry) => entry.name === database);
     } catch {
         return true;
     }
 };
 
 const idb_open = (database: string, version?: number, stores?: string[]): Promise<IDBDatabase> =>
     new Promise((resolve, reject) => {
         const request = indexedDB.open(database, version);
         request.onblocked = () => {
             log_idb(`open_blocked`, { database, version, stores });
         };
         request.onupgradeneeded = () => {
             if (!stores || stores.length === 0) return;
             const db = request.result;
             const existing_stores = Array.from(db.objectStoreNames);
             log_idb(`open_upgrade`, {
                 database,
                 version,
                 stores,
                 existing_stores
             });
             for (const store of stores) {
                 if (!db.objectStoreNames.contains(store)) db.createObjectStore(store);
             }
         };
         request.onsuccess = () => resolve(request.result);
         request.onerror = () => {
             if (request.error) reject(request.error);
             else reject(new Error("idb_open_failed"));
         };
     });
 
 const idb_store_ensure_all = async (database: string, stores: string[]): Promise<void> => {
     if (stores.length === 0) return;
     const target_stores = Array.from(new Set(stores));
     log_idb(`ensure_start`, { database, target_stores });
     let attempt = 0;
     while (attempt < 5) {
         attempt++;
         const db = await idb_open(database);
         const missing = idb_missing_stores(db, target_stores);
         const version = db.version;
         const existing_stores = Array.from(db.objectStoreNames);
         log_idb(`ensure_check`, {
             database,
             attempt,
             version,
             existing_stores,
             missing
         });
         if (missing.length === 0) {
             db.close();
             return;
         }
         db.close();
         try {
             log_idb(`ensure_upgrade`, {
                 database,
                 attempt,
                 next_version: version + 1,
                 missing
             });
             const upgraded = await idb_open(database, version + 1, missing);
             const still_missing = idb_missing_stores(upgraded, target_stores);
             const upgraded_stores = Array.from(upgraded.objectStoreNames);
             log_idb(`ensure_upgraded`, {
                 database,
                 attempt,
                 version: upgraded.version,
                 upgraded_stores,
                 still_missing
             });
             upgraded.close();
             if (still_missing.length === 0) return;
         } catch (e) {
             if (e instanceof DOMException && e.name === "VersionError") continue;
             throw e;
         }
     }
 };
 
 const idb_bootstrap_key = (database: string, stores: string[]): string =>
     `${database}:${stores.join("|")}`;
 
 const idb_store_bootstrap_ready = async (database: string, stores: string[]): Promise<void> => {
     const key = idb_bootstrap_key(database, stores);
     const pending = IDB_BOOTSTRAP_PROMISES.get(key);
     if (pending) return await pending;
     const promise = idb_store_ensure_all(database, stores);
     IDB_BOOTSTRAP_PROMISES.set(key, promise);
     try {
         await promise;
     } catch (e) {
         IDB_BOOTSTRAP_PROMISES.delete(key);
         throw e;
     }
 };
 
 export const idb_store_ensure = async (database: string, store: string): Promise<void> => {
     if (typeof indexedDB === "undefined") return;
     if (database === RADROOTS_IDB_DATABASE) {
         await idb_store_bootstrap(database);
         if (RADROOTS_IDB_STORE_SET.has(store)) return;
     }
     await idb_store_ensure_all(database, [store]);
 };
 
 export const idb_store_bootstrap = async (database: string, stores?: string[]): Promise<void> => {
     if (typeof indexedDB === "undefined") return;
     const target_stores = stores ?? (database === RADROOTS_IDB_DATABASE ? RADROOTS_IDB_STORES : []);
     if (target_stores.length === 0) return;
     await idb_store_bootstrap_ready(database, target_stores);
 };
 
 export const idb_store_exists = async (database: string, store: string): Promise<boolean> => {
     if (typeof indexedDB === "undefined") return false;
     const known = await idb_database_exists(database);
     if (!known) return false;
     try {
         const db = await idb_open(database);
         const exists = db.objectStoreNames.contains(store);
         db.close();
         return exists;
     } catch {
         return false;
     }
 };