idb-prime-ts/lib/index.js

A lightweight and efficient and flexible JS/TS library for managing IndexedDB operations in web browsers. Provides utility functions for CRUD operations, object store management, and indexed queries.

function openDB({ dbName, dbVersion, objectStoreName, indexes = false, delObjectStore = false, }) {
    return new Promise((resolve, reject) => {
        let openRequest = indexedDB.open(dbName, dbVersion);
        openRequest.onupgradeneeded = function () {
            let db = openRequest.result;
            if (delObjectStore && db.objectStoreNames.contains(objectStoreName)) {
                db.deleteObjectStore(objectStoreName);
            }
            else if (!db.objectStoreNames.contains(objectStoreName)) {
                const objStore = db.createObjectStore(objectStoreName, {
                    keyPath: 'id',
                    autoIncrement: true,
                });
                if (indexes)
                    indexes.map((el) => {
                        objStore.createIndex(el.indexName, el.indexName, { unique: el.unique });
                    });
            }
        };
        openRequest.onerror = () => reject(openRequest.error);
        openRequest.onsuccess = () => resolve(openRequest.result);
    });
}
export const dbVersionIDB = async (dbName, dbVersion) => {
    if (dbVersion) {
        return dbVersion <= 0.5 ? 1 : Math.abs(Math.round(dbVersion));
    }
    else {
        const allDb = await indexedDB.databases();
        const findDb = allDb.find((el) => el.name === dbName);
        return !!findDb ? Number(findDb.version) : 1;
    }
};
const getDB = async (args) => {
    const dbV = await dbVersionIDB(args.dbName, args.dbVersion);
    const db = await openDB({ ...args, dbVersion: dbV });
    return db;
};
const getObjectStore = async (args) => {
    const db = await getDB(args);
    return db.transaction([args.objectStoreName], args.readOrWrite).objectStore(args.objectStoreName);
};
export async function addToIDB(args) {
    const objectStore = await getObjectStore({ ...args, readOrWrite: 'readwrite' });
    return new Promise((resolve, reject) => {
        const request = objectStore.add(args.obj);
        request.onsuccess = () => resolve(request.result);
        request.onerror = () => reject(request.error);
    });
}
export async function getByIndexIDB(args) {
    const objectStore = await getObjectStore({ ...args, readOrWrite: 'readonly' }), getIndex = objectStore.index(args.index), request = args.condition ? getIndex.openCursor(args.condition) : getIndex.openCursor();
    return new Promise((resolve, reject) => {
        let myRes = [];
        request.onsuccess = (event) => {
            let cursor = event.target.result;
            if (cursor) {
                myRes.push(cursor.value);
                cursor.continue();
            }
            else {
                resolve(myRes);
            }
        };
        request.onerror = () => reject(request.error);
    });
}
export async function getByIdIDB(args) {
    const objectStore = await getObjectStore({ ...args, readOrWrite: 'readonly' });
    return new Promise((resolve, reject) => {
        let request = objectStore.get(args.id);
        request.onsuccess = (event) => resolve(event.target.result);
        request.onerror = () => reject(request.error);
    });
}
export async function getAllObjStoreIDB(args) {
    const objectStore = await getObjectStore({ ...args, readOrWrite: 'readonly' });
    return new Promise((resolve, reject) => {
        const request = objectStore.getAll();
        request.onsuccess = (event) => resolve(event.target.result);
        request.onerror = () => reject(request.error);
    });
}
export async function delByIndexIDB(args) {
    const objectStore = await getObjectStore({ ...args, readOrWrite: 'readwrite' }), getIndex = objectStore.index(args.index), request = args.condition ? getIndex.openCursor(args.condition) : getIndex.openCursor();
    return new Promise((resolve, reject) => {
        const result = [];
        request.onsuccess = (event) => {
            let cursor = event.target.result;
            if (cursor) {
                result.push(cursor.value);
                cursor.delete();
                cursor.continue();
            }
            else {
                resolve(result);
            }
        };
        request.onerror = () => reject(request.error);
    });
}
export async function delByIdIDB(args) {
    const objectStore = await getObjectStore({ ...args, readOrWrite: 'readwrite' });
    return new Promise((resolve, reject) => {
        let request = objectStore.delete(args.id);
        request.onsuccess = (event) => resolve(event.target.readyState);
        request.onerror = () => reject(request.error);
    });
}
export const delObjectStore = async (args) => {
    const lastV = (await dbVersionIDB(args.dbName)) + 1;
    const delReq = await openDB({ ...args, dbVersion: lastV, delObjectStore: true });
};
export async function updateByIdIDB(args) {
    const objectStore = await getObjectStore({ ...args, readOrWrite: 'readwrite' });
    return new Promise((resolve, reject) => {
        let getReq = objectStore.get(args.id);
        getReq.onsuccess = (event) => {
            const newData = { ...event.target.result, ...args.updateItem };
            const updateReq = objectStore.put(newData);
            updateReq.onsuccess = () => resolve(newData);
            updateReq.onerror = () => errHandle(updateReq.error);
        };
        getReq.onerror = () => errHandle(getReq.error);
        function errHandle(res) {
            reject(res);
        }
    });
}
export async function updateByIndexIDB(args) {
    const objectStore = await getObjectStore({ ...args, readOrWrite: 'readwrite' }), getIndex = objectStore.index(args.index), request = args.condition ? getIndex.openCursor(args.condition) : getIndex.openCursor();
    return new Promise((resolve, reject) => {
        const result = [];
        const errHandle = (errMessage) => reject(errMessage);
        request.onsuccess = (event) => {
            let cursor = event.target.result;
            if (cursor) {
                const newItem = { ...cursor.value, ...args.updateItem };
                result.push(newItem);
                const updateReq = objectStore.put(newItem);
                updateReq.onsuccess = () => cursor.continue();
                updateReq.onerror = () => errHandle(updateReq.error);
            }
            else {
                resolve(result);
            }
        };
        request.onerror = () => errHandle(request.error);
    });
}