error-flux/dist/db/index.js

Network request interceptor and logger for web applications

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import store from "../state/store";
import genUUID from "../utils/gen-uuid";
export function initDB(dbName_1, storeName_1) {
    return __awaiter(this, arguments, void 0, function* (dbName, storeName, dbVersion = 1) {
        return new Promise((resolve, reject) => {
            const request = indexedDB.open(dbName, dbVersion);
            request.onerror = () => {
                reject(new Error("Failed to open database"));
            };
            request.onsuccess = (event) => {
                resolve(event.target.result);
            };
            request.onupgradeneeded = (event) => {
                const db = event.target.result;
                Object.values(storeName).forEach((storeName) => {
                    if (!db.objectStoreNames.contains(storeName)) {
                        db.createObjectStore(storeName, { keyPath: "id" });
                    }
                });
            };
        });
    });
}
export function saveNetworkLogs(logs) {
    return __awaiter(this, void 0, void 0, function* () {
        const { dbName, storeName } = store.getState();
        const db = yield initDB(dbName, storeName);
        return new Promise((resolve, reject) => {
            const transaction = db.transaction([storeName.networkLogs], "readwrite");
            const store = transaction.objectStore(storeName.networkLogs);
            const logEntry = {
                id: genUUID(),
                logs,
            };
            const request = store.add(logEntry);
            request.onsuccess = () => resolve();
            request.onerror = () => reject(new Error("Failed to save logs"));
        });
    });
}
export function getNetworkLogs() {
    return __awaiter(this, void 0, void 0, function* () {
        const { dbName, storeName } = store.getState();
        const db = yield initDB(dbName, storeName);
        return new Promise((resolve, reject) => {
            const transaction = db.transaction([storeName.networkLogs], "readonly");
            const store = transaction.objectStore(storeName.networkLogs);
            const request = store.getAll();
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(new Error("Failed to retrieve logs"));
        });
    });
}
export function saveConsoleErrors(errors) {
    return __awaiter(this, void 0, void 0, function* () {
        const { dbName, storeName } = store.getState();
        const db = yield initDB(dbName, storeName);
        return new Promise((resolve, reject) => {
            const transaction = db.transaction([storeName.consoleErrors], "readwrite");
            const store = transaction.objectStore(storeName.consoleErrors);
            const errorEntry = {
                id: genUUID(),
                errors,
            };
            const request = store.add(errorEntry);
            request.onsuccess = () => resolve();
            request.onerror = () => reject(new Error("Failed to save console errors"));
        });
    });
}
export function getConsoleErrors() {
    return __awaiter(this, void 0, void 0, function* () {
        const { dbName, storeName } = store.getState();
        const db = yield initDB(dbName, storeName);
        return new Promise((resolve, reject) => {
            const transaction = db.transaction([storeName.consoleErrors], "readonly");
            const store = transaction.objectStore(storeName.consoleErrors);
            const request = store.getAll();
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(new Error("Failed to retrieve console errors"));
        });
    });
}
export function saveUnhandledErrors(errors) {
    return __awaiter(this, void 0, void 0, function* () {
        const { dbName, storeName } = store.getState();
        const db = yield initDB(dbName, storeName);
        return new Promise((resolve, reject) => {
            const transaction = db.transaction([storeName.unhandledErrors], "readwrite");
            const store = transaction.objectStore(storeName.unhandledErrors);
            const errorEntry = {
                id: genUUID(),
                errors,
            };
            const request = store.add(errorEntry);
            request.onsuccess = () => resolve();
            request.onerror = () => reject(new Error("Failed to save unhandled errors"));
        });
    });
}
export function getUnhandledErrors() {
    return __awaiter(this, void 0, void 0, function* () {
        const { dbName, storeName } = store.getState();
        const db = yield initDB(dbName, storeName);
        return new Promise((resolve, reject) => {
            const transaction = db.transaction([storeName.unhandledErrors], "readonly");
            const store = transaction.objectStore(storeName.unhandledErrors);
            const request = store.getAll();
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(new Error("Failed to retrieve unhandled errors"));
        });
    });
}
//# sourceMappingURL=index.js.map