fwk-indexdb/index.js

Framework web index DB manager

let DBNAME
const VERSION = 3

let db
let appName

console.log('fwk-indexdb CONSTRUCTOR')

const api = {
    async init (config) {
        appName = config.appName
        DBNAME = `TBX_${config.env}`
        await openDB()
    },
    async getMyMessages (type) {
        return new Promise(async (resolve) => {
            try {
                await openDB()
                const transaction = db.transaction(['messages'])
                const messages = transaction.objectStore('messages')

                let request
                if (type)
                    request = messages.index('typeIndex').getAll(type)
                else
                    request = messages.index('targetIndex').getAll(appName)

                request.onsuccess = async (event) => {
                    const arr = request.result || []
                    if (!type) {
                        for (const msg of arr) {
                            await api.deleteMessage(msg.datetime)
                        }
                    }
                    await db.close()
                    resolve(arr)
                }
                request.onerror = async event => {
                    console.log('Error al leer IndexDB: ', event)
                    await db.close()
                    resolve([])
                }
            } catch (error) {
                await db.close()
                resolve([])
            }
        })
    },
    async deleteMessage (id) {
        return new Promise(async (resolve, reject) => {
            await openDB()
            const transaction = db.transaction(['messages'], 'readwrite')
            const messages = transaction.objectStore('messages')
            if (id) {
                const request = messages.delete(id)
                request.onsuccess = async (event) => {
                    console.log('on delete success:', event)
                    await db.close()
                    resolve()
                }
                request.onerror = async (event) => {
                    console.log('on delete error:', event)
                    await db.close()
                    reject(event)
                }
            }
        })
    },
    async updateMessage (msg) {
        return new Promise(async (resolve, reject) => {
            await openDB()
            if (Object.keys(msg.payload).length === 0) {
                console.log('NO DB available ')
                await db.close()
                resolve()
                return
            }

            const transaction = db.transaction(['messages'], 'readwrite')
            const messages = transaction.objectStore('messages')
            const request = messages.delete(msg.datetime)

            request.onsuccess = async (event) => {
                console.log('on delete success:', event)
                await db.close()
                resolve()
            }
            request.onerror = async (event) => {
                console.log('on delete error:', event)
                await db.close()
                reject(event)
            }
        })
    },
    async insertMessage (obj) {
        obj.datetime = new Date().getTime().toString()
        return new Promise(async (resolve, reject) => {
            await openDB()
            const transaction = db.transaction(['messages'], 'readwrite')
            const messages = transaction.objectStore('messages')

            const request = messages.put(obj)
            request.onsuccess = async (event) => {
                console.log('on insert success:', event)
                await db.close()
                resolve(obj.datetime)
            }
            request.onerror = async (event) => {
                console.log('on insert error:', event)
                await db.close()
                reject()
            }
        })
    }
}
export default api

async function openDB () {
    return new Promise((resolve, reject) => {
        const openRequest = indexedDB.open(DBNAME, VERSION)

        openRequest.onupgradeneeded = evt => {
            db = evt.target.result || db

            // always delete the old store to avoid errors
            if (db.objectStoreNames.contains('messages')) db.deleteObjectStore('messages')

            const objStore = db.createObjectStore('messages', { keyPath: 'datetime', })
            const indexs = {
                targetIndex: 'target', // indexName: field of the object
                typeIndex: 'type',
            }

            for (const indexName in indexs) {
                objStore.createIndex(indexName, indexs[indexName], { unique: false })
            }
        }
        openRequest.onsuccess = event => {
            db = event.target.result
            resolve()
        }
        openRequest.onerror = event => {
            console.log('Error al abrir la base de datos', event)
            reject(event)
        }
    })
}