@lcap/nasl/out/service/storage/taskQueue.js

NetEase Application Specific Language

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getTaskQueueTimestamps = exports.getAllTaskQueueRecords = exports.deleteTaskQueueFromIndexedDB = exports.deleteExpiredTaskQueueRecords = exports.loadTaskQueueFromIndexedDB = exports.saveTaskQueueToIndexedDB = void 0;
const lodash_1 = require("lodash");
function setupTaskQueueSchema(event) {
    const db = event.target.result;
    const objectStore = db.createObjectStore('taskQueueRecord', { keyPath: 'timestamp' });
    objectStore.createIndex('appId', 'appId');
}
async function saveTaskQueueToIndexedDB(taskQueueRecord) {
    return new Promise((resolve, reject) => {
        const request = indexedDB.open('taskQueue', 1);
        request.onupgradeneeded = setupTaskQueueSchema;
        request.onsuccess = (event) => {
            try {
                const db = event.target.result;
                const transaction = db.transaction('taskQueueRecord', 'readwrite');
                const objectStore = transaction.objectStore('taskQueueRecord');
                const cloned = (0, lodash_1.cloneDeep)(taskQueueRecord);
                objectStore.put(cloned);
                transaction.oncomplete = () => {
                    db.close();
                    resolve();
                };
                transaction.onerror = (event) => {
                    reject(event.target.error);
                };
            }
            catch (err) {
                console.error('Failed to save task queue to IndexedDB', err);
                reject(err);
            }
        };
        request.onerror = function (event) {
            console.error('Failed to open database', event);
            reject(event.target.error);
        };
    });
}
exports.saveTaskQueueToIndexedDB = saveTaskQueueToIndexedDB;
async function loadTaskQueueFromIndexedDB(appId, timestamp) {
    return new Promise((resolve, reject) => {
        const request = indexedDB.open('taskQueue', 1);
        request.onupgradeneeded = setupTaskQueueSchema;
        request.onsuccess = (event) => {
            const db = event.target.result;
            const transaction = db.transaction('taskQueueRecord', 'readonly');
            const objectStore = transaction.objectStore('taskQueueRecord');
            const getRequest = objectStore.get(timestamp);
            getRequest.onsuccess = (event) => {
                const record = event.target.result;
                if (record && record.appId === appId) {
                    resolve(record);
                }
                else {
                    resolve(null);
                }
            };
            getRequest.onerror = (event) => {
                reject(event.target.error);
            };
            transaction.oncomplete = () => {
                db.close();
            };
            transaction.onerror = (event) => {
                db.close();
                reject(event.target.error);
            };
        };
        request.onerror = (event) => {
            console.error('Failed to open database', event);
            reject(event.target.error);
        };
    });
}
exports.loadTaskQueueFromIndexedDB = loadTaskQueueFromIndexedDB;
async function deleteExpiredTaskQueueRecords() {
    return new Promise((resolve, reject) => {
        const request = indexedDB.open('taskQueue', 1);
        request.onupgradeneeded = setupTaskQueueSchema;
        request.onsuccess = (event) => {
            const db = event.target.result;
            const transaction = db.transaction('taskQueueRecord', 'readwrite');
            const objectStore = transaction.objectStore('taskQueueRecord');
            const taskQueueTTL = window.localStorage.getItem('taskQueueTTL');
            const parsedTTL = taskQueueTTL ? parseInt(taskQueueTTL, 10) : null;
            const cutoffTimestamp = Date.now() - (parsedTTL && !isNaN(parsedTTL) ? parsedTTL : 7 * 24 * 60 * 60 * 1000);
            const range = IDBKeyRange.upperBound(cutoffTimestamp);
            const expiredRecordsRequest = objectStore.openKeyCursor(range);
            expiredRecordsRequest.onsuccess = (event) => {
                const cursor = event.target.result;
                try {
                    if (cursor) {
                        objectStore.delete(cursor.primaryKey);
                        cursor.continue();
                    }
                }
                catch (err) {
                    console.error('Failed to delete expired task queue records', err);
                    reject(err);
                }
            };
            transaction.oncomplete = () => {
                db.close();
                resolve();
            };
            transaction.onerror = (event) => {
                db.close();
                reject(event.target.error);
            };
            expiredRecordsRequest.onerror = (event) => {
                reject(event.target.error);
            };
        };
        request.onerror = (event) => {
            console.error('Failed to open database', event);
            reject(event);
        };
    });
}
exports.deleteExpiredTaskQueueRecords = deleteExpiredTaskQueueRecords;
async function deleteTaskQueueFromIndexedDB(appId, timestamp) {
    return new Promise((resolve, reject) => {
        const request = indexedDB.open('taskQueue', 1);
        request.onupgradeneeded = setupTaskQueueSchema;
        request.onsuccess = (event) => {
            const db = event.target.result;
            const transaction = db.transaction('taskQueueRecord', 'readwrite');
            const objectStore = transaction.objectStore('taskQueueRecord');
            const getRequest = objectStore.get(timestamp);
            getRequest.onsuccess = (event) => {
                const record = event.target.result;
                if (record && record.appId === appId) {
                    const deleteRequest = objectStore.delete(timestamp);
                    deleteRequest.onerror = (event) => {
                        reject(event.target.error);
                    };
                }
                else {
                    console.warn(`Task queue record with timestamp ${timestamp} not found for appId ${appId}`);
                }
            };
            getRequest.onerror = (event) => {
                reject(event.target.error);
            };
            transaction.oncomplete = () => {
                db.close();
                resolve();
            };
            transaction.onerror = (event) => {
                db.close();
                reject(event.target.error);
            };
        };
        request.onerror = (event) => {
            console.error('Failed to open database', event);
            reject(event.target.error);
        };
    });
}
exports.deleteTaskQueueFromIndexedDB = deleteTaskQueueFromIndexedDB;
async function getAllTaskQueueRecords(appId) {
    return new Promise((resolve, reject) => {
        const request = indexedDB.open('taskQueue', 1);
        request.onupgradeneeded = setupTaskQueueSchema;
        request.onsuccess = (event) => {
            const db = event.target.result;
            const transaction = db.transaction('taskQueueRecord', 'readonly');
            const objectStore = transaction.objectStore('taskQueueRecord');
            const index = objectStore.index('appId');
            const range = IDBKeyRange.only(appId);
            const result = [];
            const cursorRequest = index.openCursor(range);
            cursorRequest.onsuccess = (event) => {
                const cursor = event.target.result;
                if (cursor) {
                    result.push(cursor.value);
                    cursor.continue();
                }
                else {
                    resolve(result);
                }
            };
            transaction.oncomplete = () => {
                db.close();
            };
            transaction.onerror = (event) => {
                db.close();
                reject(event.target.error);
            };
            cursorRequest.onerror = (event) => {
                reject(event.target.error);
            };
        };
        request.onerror = (event) => {
            console.error('Failed to open database', event);
            reject(event.target.error);
        };
    });
}
exports.getAllTaskQueueRecords = getAllTaskQueueRecords;
async function getTaskQueueTimestamps(appId) {
    return new Promise((resolve, reject) => {
        const request = indexedDB.open('taskQueue', 1);
        request.onupgradeneeded = setupTaskQueueSchema;
        request.onsuccess = (event) => {
            const db = event.target.result;
            const transaction = db.transaction('taskQueueRecord', 'readonly');
            const objectStore = transaction.objectStore('taskQueueRecord');
            const index = objectStore.index('appId');
            const range = IDBKeyRange.only(appId);
            const result = [];
            const cursorRequest = index.openKeyCursor(range);
            cursorRequest.onsuccess = (event) => {
                const cursor = event.target.result;
                if (cursor) {
                    result.push(cursor.primaryKey);
                    cursor.continue();
                }
                else {
                    resolve(result.sort((a, b) => b - a));
                }
            };
            cursorRequest.onerror = (event) => {
                reject(event.target.error);
            };
            transaction.oncomplete = () => {
                db.close();
            };
            transaction.onerror = (event) => {
                db.close();
                reject(event.target.error);
            };
        };
        request.onerror = (event) => {
            console.error('Failed to open database', event);
            reject(event.target.error);
        };
    });
}
exports.getTaskQueueTimestamps = getTaskQueueTimestamps;
//# sourceMappingURL=taskQueue.js.map