fix: upgrade idb

package.json

@@ -39,7 +39,7 @@
         "@types/chrome": "0.1.37",
         "@types/decompress": "^4.2.7",
         "@types/jest": "^30.0.0",
-        "@types/node": "^25.3.0",
+        "@types/node": "^25.3.1",
         "@types/punycode": "^2.1.4",
         "@vue/babel-plugin-jsx": "^2.0.1",
         "babel-loader": "^10.0.0",

src/background/index.ts

@@ -15,7 +15,7 @@ import badgeTextManager from "./badge-manager"
 import initBrowserAction from "./browser-action-manager"
 import initCsHandler from "./content-script-handler"
 import initDataCleaner from "./data-cleaner"
-import handleInstall from "./install-handler"
+import handleInstall from './install-handler'
 import initLimitProcessor from "./limit-processor"
 import MessageDispatcher from "./message-dispatcher"
 import VersionMigrator from "./migrator"

src/background/migrator/indexed-migrator.ts

@@ -1,10 +1,28 @@
+import { BaseIDBStorage } from '@db/common/indexed-storage'
+import { IDBStatDatabase } from '@db/stat-database/idb'
 import timelineDatabase from '@db/timeline-database'
+import IDBTimelineDatabase from '@db/timeline-database/idb'
 import type { Migrator } from './types'
 
+async function upgradeIndexedDB() {
+    try {
+        const storages: BaseIDBStorage<any>[] = [new IDBStatDatabase(), new IDBTimelineDatabase()]
+        for (const storage of storages) {
+            await storage.upgrade()
+        }
+        console.log('IndexedDB upgraded successfully')
+    } catch (error) {
+        console.error('Failed to upgrade IndexedDB', error)
+    }
+}
+
 class IndexedMigrator implements Migrator {
     onInstall(): void {
     }
-    onUpdate(_version: string): void {
+
+    async onUpdate(_version: string): Promise<void> {
+        await upgradeIndexedDB()
+
         timelineDatabase.migrateFromClassic()
             .then(() => console.log('Timeline data migrated to IndexedDB'))
             .catch(e => console.error('Failed to migrate timeline data to IndexedDB', e))

src/database/common/indexed-storage.ts

@@ -63,6 +63,21 @@ export async function iterateCursor<T = unknown>(
     })
 }
 
+type TransactionError = 'Connection' | 'StoreNotFound' | 'Unknown'
+
+const detectTransactionError = (err: unknown): TransactionError => {
+    if (!(err instanceof DOMException)) {
+        return 'Unknown'
+    }
+    if (err.name === 'InvalidStateError' || err.name === 'AbortError') {
+        return 'Connection'
+    }
+    if (err.name === 'NotFoundError') {
+        return 'StoreNotFound'
+    }
+    return 'Unknown'
+}
+
 export function closedRangeKey(lower: IDBValidKey | undefined, upper: IDBValidKey | undefined): IDBKeyRange | undefined {
     if (lower !== undefined && upper !== undefined) {
         if (lower > upper) {
@@ -87,53 +102,131 @@ export abstract class BaseIDBStorage<T = Record<string, unknown>> {
     private DB_NAME = `tt4b_${chrome.runtime.id}` as const
 
     private db: IDBDatabase | undefined
+    private static initPromises = new Map<string, Promise<IDBDatabase>>()
+
     abstract indexes: Index<T>[]
     abstract key: Key<T> | Key<T>[]
     abstract table: Table
 
     protected async initDb(): Promise<IDBDatabase> {
         if (this.db) return this.db
 
+        let initPromise = BaseIDBStorage.initPromises.get(this.table)
+        if (!initPromise) {
+            initPromise = this.doInitDb()
+            BaseIDBStorage.initPromises.set(this.table, initPromise)
+        }
+
+        try {
+            this.db = await initPromise
+            this.setupDbCloseHandler(this.db)
+            return this.db
+        } catch (error) {
+            BaseIDBStorage.initPromises.delete(this.table)
+            throw error
+        }
+    }
+
+    private setupDbCloseHandler(db: IDBDatabase): void {
+        db.onclose = () => {
+            if (this.db !== db) return
+
+            this.db = undefined
+            BaseIDBStorage.initPromises.delete(this.table)
+        }
+    }
+
+    private async doInitDb(): Promise<IDBDatabase> {
         const factory = typeof window !== 'undefined' ? window.indexedDB : globalThis.indexedDB
-        const checkRequest = factory.open(this.DB_NAME)
 
-        return new Promise((resolve, reject) => {
-            checkRequest.onsuccess = () => {
-                const db = checkRequest.result
-                const storeExisted = db.objectStoreNames.contains(this.table)
-                const needUpgrade = !storeExisted || this.needUpgradeIndexes(db)
+        const checkDb = await new Promise<IDBDatabase>((resolve, reject) => {
+            const checkRequest = factory.open(this.DB_NAME)
+            checkRequest.onsuccess = () => resolve(checkRequest.result)
+            checkRequest.onerror = () => reject(checkRequest.error || new Error("Failed to open database"))
+        })
 
-                if (!needUpgrade) {
-                    this.db = db
-                    return resolve(db)
-                }
+        return checkDb
+    }
+
+    // Only used for testing, be careful when using in production
+    public async clear(): Promise<void> {
+        await this.withStore(store => store.clear(), 'readwrite')
+    }
+
+    async upgrade(): Promise<void> {
+        const factory = typeof window !== 'undefined' ? window.indexedDB : globalThis.indexedDB
+
+        const checkDb = await new Promise<IDBDatabase>((resolve, reject) => {
+            const checkRequest = factory.open(this.DB_NAME)
+            checkRequest.onsuccess = () => resolve(checkRequest.result)
+            checkRequest.onerror = () => reject(checkRequest.error || new Error("Failed to open database"))
+            checkRequest.onblocked = () => {
+                console.warn(`Database check blocked for "${this.table}" (DB: ${this.DB_NAME}), waiting for other connections to close`)
+            }
+        })
+
+        const storeExisted = checkDb.objectStoreNames.contains(this.table)
+        const needUpgrade = !storeExisted || this.needUpgradeIndexes(checkDb)
+
+        if (!needUpgrade) {
+            checkDb.close()
+            return
+        }
 
-                const currentVersion = db.version
-                db.close()
+        const currentVersion = checkDb.version
+        checkDb.close()
 
-                const upgradeRequest = factory.open(this.DB_NAME, currentVersion + 1)
+        return new Promise<void>((resolve, reject) => {
+            const upgradeRequest = factory.open(this.DB_NAME, currentVersion + 1)
 
-                upgradeRequest.onupgradeneeded = () => {
+            upgradeRequest.onupgradeneeded = () => {
+                try {
                     const upgradeDb = upgradeRequest.result
                     const transaction = upgradeRequest.transaction
-                    if (!transaction) return reject("Failed to get transaction of upgrading request")
+                    if (!transaction) {
+                        reject(new Error("Failed to get transaction of upgrading request"))
+                        return
+                    }
+
+                    transaction.onerror = () => {
+                        reject(transaction.error || new Error("Transaction failed"))
+                    }
+
+                    transaction.onabort = () => {
+                        reject(new Error("Upgrade transaction was aborted"))
+                    }
 
                     let store = upgradeDb.objectStoreNames.contains(this.table)
                         ? transaction.objectStore(this.table)
-                        : upgradeDb.createObjectStore(this.table, { keyPath: this.key })
+                        : upgradeDb.createObjectStore(this.table, { keyPath: this.key as string | string[] })
                     this.createIndexes(store)
+                } catch (error) {
+                    console.error("Failed to upgrade database in onupgradeneeded", error)
+                    upgradeRequest.transaction?.abort()
+                    reject(error instanceof Error ? error : new Error(String(error)))
                 }
+            }
 
-                upgradeRequest.onsuccess = () => {
-                    console.log("IndexedDB upgraded")
-                    this.db = upgradeRequest.result
-                    resolve(upgradeRequest.result)
-                }
+            upgradeRequest.onsuccess = () => {
+                console.log(`IndexedDB upgraded for table "${this.table}"`)
+                upgradeRequest.result.close()
+                resolve()
+            }
 
-                upgradeRequest.onerror = () => reject(upgradeRequest.error)
+            upgradeRequest.onerror = (event) => {
+                console.error("Failed to upgrade database", event, upgradeRequest.error)
+                reject(upgradeRequest.error || new Error("Failed to upgrade database"))
             }
 
-            checkRequest.onerror = () => reject(checkRequest.error)
+            upgradeRequest.onblocked = () => {
+                const blockingTables = Array.from(BaseIDBStorage.initPromises.keys())
+                    .filter(table => table !== this.table)
+                console.warn(
+                    `Database upgrade blocked for table "${this.table}" (DB: ${this.DB_NAME}), ` +
+                    `waiting for other connections to close. ` +
+                    `Other tables with active connections: ${blockingTables.length > 0 ? blockingTables.join(', ') : 'none'}`
+                )
+            }
         })
     }
 
@@ -170,27 +263,45 @@ export abstract class BaseIDBStorage<T = Record<string, unknown>> {
     }
 
     protected async withStore<T = unknown>(operation: (store: IDBObjectStore) => T | Promise<T>, mode?: IDBTransactionMode): Promise<T> {
-        const db = await this.initDb()
-        const trans = db.transaction(this.table, mode ?? 'readwrite')
-        try {
-            const store = trans.objectStore(this.table)
-            const result = await operation(store)
-            // Waiting for transaction completed
-            await new Promise<void>((resolve, reject) => {
-                trans.oncomplete = () => resolve()
-                trans.onerror = () => reject(trans.error)
-                trans.onabort = () => reject(new Error('Transaction aborted'))
-            })
-            return result
-        } catch (e) {
-            console.error("Failed to process with transaction", e)
-            if (!trans.error && trans.mode !== 'readonly') {
-                try {
-                    trans.abort()
-                } catch (ignored) { }
+        let db = await this.initDb()
+
+        for (let retryCount = 0; retryCount < 2; retryCount++) {
+            let trans: IDBTransaction | undefined
+            try {
+                trans = db.transaction(this.table, mode ?? 'readwrite')
+                const store = trans.objectStore(this.table)
+                const result = await operation(store)
+                const transaction = trans
+                await new Promise<void>((resolve, reject) => {
+                    transaction.oncomplete = () => resolve()
+                    transaction.onerror = () => reject(transaction.error)
+                    transaction.onabort = () => reject(new Error('Transaction aborted'))
+                })
+                return result
+            } catch (e) {
+                const errorType = detectTransactionError(e)
+
+                if (errorType === 'Unknown') {
+                    console.error("Failed to process with transaction", e)
+                    if (trans && !trans.error && trans.mode !== 'readonly') {
+                        try {
+                            trans.abort()
+                        } catch (ignored) { }
+                    }
+                    throw e
+                }
+
+                if (errorType === 'StoreNotFound') {
+                    this.db?.close()
+                    await this.upgrade()
+                }
+
+                this.db = undefined
+                BaseIDBStorage.initPromises.delete(this.table)
+                db = await this.initDb()
             }
-            throw e
         }
+        throw new Error("Max retries exceeded")
     }
 
     protected assertIndex(store: IDBObjectStore, key: Key<T> | Key<T>[]): IDBIndex {

src/database/stat-database/idb.ts

@@ -1,5 +1,5 @@
 import { BaseIDBStorage, closedRangeKey, IndexResult, iterateCursor, type Key, req2Promise, type Table } from '@db/common/indexed-storage'
-import { cvtGroupId2Host, formatDateStr, increase, zeroRow } from './common'
+import { cvtGroupId2Host, formatDateStr, GROUP_PREFIX, increase, zeroRow } from './common'
 import { filterDate, filterHost, filterNumberRange, processCondition, type ProcessedCondition } from './condition'
 import type { StatCondition, StatDatabase } from './types'
 
@@ -8,15 +8,7 @@ type StoredRow = timer.core.Row & {
     groupId?: number
 }
 
-function fromStoredRow(stored: StoredRow): timer.core.Row {
-    if (stored.groupId !== undefined) {
-        const { groupId, ...row } = stored
-        return { ...row, host: cvtGroupId2Host(groupId) }
-    }
-    return stored
-}
-
-const GROUP_HOST_PATTERN = /^_g_(\d+)$/
+const GROUP_HOST_PATTERN = new RegExp(`^${GROUP_PREFIX}(\\d+)$`)
 
 const INDEXES: (Key<StoredRow> | Key<StoredRow>[])[] = [
     'date', 'host', 'groupId',
@@ -144,12 +136,7 @@ export class IDBStatDatabase extends BaseIDBStorage<StoredRow> implements StatDa
 
         const rows = await iterateCursor<StoredRow>(cursorReq)
         for (const row of rows) {
-            if (expectGroup) {
-                if (!isGroup(row)) continue
-            } else {
-                if (isGroup(row)) continue
-            }
-
+            if (expectGroup !== isGroup(row)) continue
             if (!filter(row)) continue
 
             if (expectGroup) {
@@ -196,9 +183,8 @@ export class IDBStatDatabase extends BaseIDBStorage<StoredRow> implements StatDa
 
             await iterateCursor(cursorReq, cursor => {
                 const stored = cursor.value as StoredRow | undefined
-                if (stored && !isGroup(stored)) {
-                    toUpdate[stored.host] = fromStoredRow(stored)
-                }
+                if (!stored || isGroup(stored)) return
+                toUpdate[stored.host] = stored
             })
 
             for (const [host, result] of Object.entries(data)) {
@@ -332,15 +318,7 @@ export class IDBStatDatabase extends BaseIDBStorage<StoredRow> implements StatDa
     }
 
     forceUpdate(...rows: timer.core.Row[]): Promise<void> {
-        return this.withStore(store => {
-            for (const row of rows) {
-                const { host, date, time, focus, run } = row
-                const groupMatch = host.match(GROUP_HOST_PATTERN)
-                const newData: StoredRow = { host, date, time, focus, run }
-                groupMatch && (newData.groupId = parseInt(groupMatch[1]))
-                store.put(newData)
-            }
-        }, 'readwrite')
+        return this.withStore(store => rows.forEach(row => store.put(row)), 'readwrite')
     }
 
     forceUpdateGroup(...rows: timer.core.Row[]): Promise<void> {