hlk_autotest/tests/utils/indexedDBUtils.ts

export async function readIndexedDB() {
    const databases = await indexedDB.databases();
    const allData: Array<{ databaseName: string; data: { key: IDBValidKey; value: any }[] }> = [];

    for (const db of databases) {
        const databaseName = db.name!;

        try {
            const dbInstance = await openDatabase(databaseName);
            const transaction = dbInstance.transaction(dbInstance.objectStoreNames, 'readonly');
            const objectStore = transaction.objectStore(dbInstance.objectStoreNames[0]);
            const storeData = await getAllDataFromObjectStore(objectStore);

            allData.push({
                databaseName,
                data: storeData,
            });

            dbInstance.close();
        } catch (error) {
            console.error(`Error reading database ${databaseName}:`, error);
        }
    }

    return allData;
}

function openDatabase(databaseName: string): Promise<IDBDatabase> {
    return new Promise((resolve, reject) => {
        const request = indexedDB.open(databaseName);

        request.onsuccess = event => resolve(event.target.result);
        request.onerror = event => reject(event.target.error);
    });
}

function getAllDataFromObjectStore(objectStore: IDBObjectStore): Promise<Array<{ key: IDBValidKey; value: any }>> {
    return new Promise((resolve, reject) => {
        const storeData: Array<{ key: IDBValidKey; value: any }> = [];
        const cursorRequest = objectStore.openCursor();

        cursorRequest.onsuccess = event => {
            const cursor = event.target.result;
            if (cursor) {
                storeData.push({ key: cursor.key, value: cursor.value });
                cursor.continue();
            } else {
                resolve(storeData);
            }
        };

        cursorRequest.onerror = event => reject(event.target.error);
    });
}

export async function writeIndexedDB(jsonData) {
    return new Promise((resolve, reject) => {
        const processDatabase = async (database, objectStoreNames) => {
            try {
                // 动态获取数据库版本号
                const version = database.version || 2;
                const openRequest = indexedDB.open(database.databaseName, version);

                // 处理数据库版本升级
                openRequest.onupgradeneeded = event => {
                    const db = event.target.result;
                    objectStoreNames.forEach(storeName => {
                        if (!db.objectStoreNames.contains(storeName)) {
                            db.createObjectStore(storeName);
                        }
                    });
                };

                // 处理数据库打开成功
                openRequest.onsuccess = async event => {
                    const db = event.target.result;
                    const table = database.data;
                    const transaction = db.transaction(objectStoreNames, 'readwrite');
                    const objectStore = transaction.objectStore(objectStoreNames[0]);

                    // 添加事务错误处理
                    transaction.onerror = event => {
                        console.error('事务失败:', event.target.error);
                        reject('事务失败');
                    };

                    let completedOperations = 0;
                    const totalOperations = table.length;

                    // 使用 Promise.all 来确保所有的写入操作完成
                    const writeOperations = table.map((item, index) => {
                        return new Promise((innerResolve, innerReject) => {
                            const addObject = objectStore.put(item.value, item.key);
                            addObject.onsuccess = () => {
                                completedOperations++;
                                if (completedOperations === totalOperations) {
                                    innerResolve('数据写入成功');
                                }
                            };
                            addObject.onerror = event => {
                                console.error('数据添加失败:', event.target.error);
                                innerReject('数据添加失败');
                            };
                        });
                    });

                    // 等待所有写入操作完成
                    try {
                        await Promise.all(writeOperations);
                        resolve('所有数据写入完成');
                    } catch (error) {
                        reject('数据写入失败');
                    }
                };

                // 错误处理
                openRequest.onerror = event => {
                    console.error('数据库打开失败:', event.target.error);
                    reject('数据库打开失败');
                };
            } catch (error) {
                reject('数据库操作失败: ' + error);
            }
        };

        // 遍历所有数据库
        const objectStoreNames = ['keyvaluepairs', 'local-forage-detect-blob-support'];
        Promise.all(jsonData.map(database => processDatabase(database, objectStoreNames)))
            .then(() => resolve('所有数据库操作完成'))
            .catch(error => reject('操作失败: ' + error));
    });
}