@cocreate/indexeddb 1.13.3 → 1.13.4

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [1.13.4](https://github.com/CoCreate-app/CoCreate-indexeddb/compare/v1.13.3...v1.13.4) (2023-09-17)
+
+
+### Bug Fixes
+
+* renamed filter to $filter ([00c58a5](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/00c58a585b27e88c735a35e9a85cf234b060347c))
+* update indexeddb() to indexeddb.send() ([6568ef6](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/6568ef68d4f38490ffc57086661d4a5b8ae3b721))
+
 ## [1.13.3](https://github.com/CoCreate-app/CoCreate-indexeddb/compare/v1.13.2...v1.13.3) (2023-09-07)
 
 

package/CoCreate.config.js

@@ -22,4 +22,4 @@ module.exports = {
             }
         }
     ]
-}
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/indexeddb",
-  "version": "1.13.3",
+  "version": "1.13.4",
   "description": "A simple indexeddb component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "indexeddb",

package/src/index.js

@@ -49,14 +49,14 @@ function setStatus(value) {
 
     if (!value) {
         indexedDbFunction = indexedDb
-        indexedDb = value;
-    } else if (!indexedDb) {
-        indexedDb = indexedDbFunction
+        send = value;
+    } else if (!send) {
+        send = indexedDbFunction
         indexedDbFunction = true
     }
 }
 
-async function indexedDb(data) {
+async function send(data) {
     try {
         let newData = [];
 
@@ -118,12 +118,12 @@ const processDatabase = (data, newData, type) => {
         if (data.method == 'read.database') {
             indexedDB.databases().then((databases) => {
                 for (let database of databases) {
-                    if (data.filter && data.filter.query) {
-                        let isFilter = queryData(database, data.filter.query)
+                    if (data.$filter && data.$filter.query) {
+                        let isFilter = queryData(database, data.$filter.query)
                         if (isFilter)
-                            newData.push({ storage: 'indexeddb', database })
+                            newData.push({ $storage: 'indexeddb', $database: database })
                     } else
-                        newData.push({ storage: 'indexeddb', database })
+                        newData.push({ $storage: 'indexeddb', $database: database })
                 }
 
                 resolve()
@@ -299,12 +299,12 @@ async function processArray(data, newData, database, type) {
             data[type] = []
 
         for (let i = 0; i < objectStoreNames.length; i++) {
-            if (data.filter && data.filter.query) {
-                let isFilter = queryData({ name: objectStoreNames[i] }, data.filter.query)
+            if (data.$filter && data.$filter.query) {
+                let isFilter = queryData({ name: objectStoreNames[i] }, data.$filter.query)
                 if (isFilter)
-                    newData.push({ name: objectStoreNames, storage: 'indexeddb', database })
+                    newData.push({ name: objectStoreNames, $storage: 'indexeddb', $database: database })
             } else
-                newData.push({ name: objectStoreNames[i], storage: 'indexeddb', database })
+                newData.push({ name: objectStoreNames[i], $storage: 'indexeddb', $database: database })
         }
     } else {
         let arrays
@@ -345,7 +345,7 @@ async function processArray(data, newData, database, type) {
             db.result.close()
 
             if (!error)
-                newData.push({ name: array, storage: 'indexeddb', database })
+                newData.push({ name: array, $storage: 'indexeddb', $database: database })
             else
                 errorHandler(data, error, database)
         }
@@ -364,10 +364,10 @@ async function processIndex(data, newData, database, array, type) {
         if (data.method == 'read.index') {
             for (let i = 0; i < indexNames.length; i++) {
                 let name = indexNames[i]
-                if (data.filter && data.filter.query)
-                    if (!(queryData({ name }, data.filter.query))) continue
+                if (data.$filter && data.$filter.query)
+                    if (!(queryData({ name }, data.$filter.query))) continue
 
-                newData.push({ name, storage: 'indexeddb', database, array })
+                newData.push({ name, $storage: 'indexeddb', $database: database, $array: array })
             }
             db.close()
         } else {
@@ -407,7 +407,7 @@ async function processIndex(data, newData, database, array, type) {
                     error = 'index does not exist'
 
                 if (!error)
-                    newData.push({ name: index, storage: 'indexeddb', database, array })
+                    newData.push({ name: index, $storage: 'indexeddb', $database: database, $array: array })
                 else
                     errorHandler(data, error, database, array)
 
@@ -419,303 +419,256 @@ async function processIndex(data, newData, database, array, type) {
 
 async function processObject(data, newData, database, array, type) {
     let db = await processDatabase({ method: 'get.database', database })
-    let filteredObjects
+
+    let isFilter
+    if (data.$filter && data.$filter.query)
+        isFilter = true
+
     let arrayExist = db.objectStoreNames.contains(array)
-    if (arrayExist) {
-        if (data.filter || data.method == 'read.object' && (!data.object || data.object && !data.object.length)) {
-            db.close()
-            filteredObjects = await readObject(data, database, array)
-            db = await processDatabase({ method: 'get.database', database })
-        }
-    } else {
-        db.close()
-        db = processDatabase({ method: 'get.database', database, array })
-        if (data.filter || data.method == 'read.object' && (!data.object || !data.object.length)) {
+    if (!arrayExist) {
+        if (data.$filter || data.method == 'read.object' && (!data.object || data.object && !data.object.length)) {
             db.close()
-            filteredObjects = await readObject(data, database, array)
-            db = processDatabase({ method: 'get.database', database })
+            db = await processDatabase({ method: 'get.database', database, array })
         }
     }
 
-    // let transaction, objectStore
-    if (array && db) {
-        var transaction = db.transaction([array], "readwrite");
-        var objectStore = transaction.objectStore(array);
-    }
+    if (!array || !db)
+        throw new Error({ error: "This is an error message.", db, array });
 
-    let objects = []
+    let transactionType = "readwrite"
+    if (data.method == 'read.object')
+        transactionType = "readonly"
 
-    if (Array.isArray(data[type]))
-        objects.push(...data[type]);
-    else if (data[type] != undefined)
-        objects.push(data[type])
-    // else if (data[type] != undefined && data.method == 'create.object')
-    //     objects.push(data[type])
-    // else if (data[type] != undefined)
-    //     objects.push({...data[type]})
+    let transaction = db.transaction([array], transactionType);
+    let objectStore = transaction.objectStore(array);
 
+    if (data[type] && !Array.isArray(data[type]))
+        data[type] = [data[type]]
 
-    if (filteredObjects && filteredObjects.length) {
-        if (data.method == 'read.object') {
-            for (let i = 0; i < filteredObjects.length; i++)
-                newData.push({ storage: 'indexeddb', database, array, ...filteredObjects[i] })
+    if (isFilter && (!data[type] || !data[type].length))
+        data[type] = [{}]
 
-        }
+    let upsert = data.upsert
+    try {
 
-        if (data.method == 'update.object') {
-            let updateData = objects[0];
-            if (updateData)
-                objects.shift();
-            for (let filterDoc of filteredObjects) {
-                filterDoc = dotNotationToObject(updateData, filterDoc)
-                objects.push(filterDoc)
-            }
-        }
+        for (let i = 0; i < data[type].length; i++) {
+            delete data[type][i].$storage
+            delete data[type][i].$database
+            delete data[type][i].$array
 
-        if (data.method == 'delete.object')
-            objects.push(...filteredObjects)
-    }
+            if (data.method == 'create.object') {
+                if (!data[type][i]._id)
+                    data[type][i]['_id'] = ObjectId()
+                data[type][i] = dotNotationToObject(data[type][i])
+                data[type][i]['created'] = { on: data.timeStamp, by: data.user_id || data.clientId }
 
-    for (let i = 0; i < objects.length; i++) {
-        // TODO deDuplcate object per array
-        delete objects[i].storage
-        delete objects[i].database
-        delete objects[i].array
-
-        if (data.method == 'update.object' || data.method == 'delete.object') {
-            if (objects[i]._id) {
+                let result = await add(objectStore, data[type][i])
+                newData.push({ $storage: 'indexeddb', $database: database, $array: array, ...result })
+            } else {
+                if (data[type][i].$filter)
+                    isFilter = true
                 if (data.organization_id)
-                    objects[i]['organization_id'] = data.organization_id
-                objects[i]['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-
-                await updateObject(data, objects[i], objectStore, database, array)
-                objects[i].storage = 'indexeddb'
-                objects[i].database = database
-                objects[i].array = array
-                newData.push(objects[i])
-            }
-        } else if (data.method == 'create.object') {
-            if (!objects[i]._id)
-                objects[i]['_id'] = ObjectId()
-            objects[i] = dotNotationToObject(objects[i])
-
-            if (data.organization_id)
-                objects[i]['organization_id'] = data.organization_id
-            objects[i]['created'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-            await addGet(data, newData, database, array, objects[i], objectStore, 'add')
-        } else if (data.method == 'read.object') {
-            if (objects[i]._id)
-                await addGet(data, newData, database, array, objects[i]._id, objectStore, 'get')
-            else
-                errorHandler(data, { message: 'requires _id', object: objects[i] }, database, objectStore.name)
-        }
-
-    }
+                    data[type][i]['organization_id'] = data.organization_id
 
-    db.close()
-}
-
-function addGet(data, newData, database, array, object, objectStore, operator) {
-    return new Promise((resolve, reject) => {
-        let request = objectStore[operator](object)
+                if (data.method == 'update.object') {
+                    if (data[type][i].$upsert)
+                        upsert = data[type][i].$upsert
 
-        request.onsuccess = function () {
-            if (request.result) {
-                if (data.method == 'read.object')
-                    object = request.result
-                object.storage = 'indexeddb'
-                object.database = database
-                object.array = array
-
-                newData.push(object)
-            }
-            resolve()
-        };
+                    if (!data[type][i]._id && upsert)
+                        data[type][i]._id = ObjectId()
+                    data[type][i]['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
+                }
 
-        request.onerror = function () {
-            errorHandler(data, { message: request.error, object }, database, objectStore.name)
-            resolve()
-        };
+                let index = 0, limit, range, direction
+                if (data[type][i]._id)
+                    range = IDBKeyRange.only(data[type][i]._id);
+                else if (isFilter) {
+                    if (data.$filter || object.$filter) {
+                        let count = objectStore.count();
+                        count.onsuccess = function () {
+                            data.$filter.count = count.result
+                        }
+                    }
 
-    });
-}
+                    let isIndex = false
+                    let indexName, direction;
+                    if (data.$filter && data.$filter.sort && data.$filter.sort[0] && data.$filter.sort[0].name) {
+                        indexName = data.$filter.sort[0].name
+                        // if (indexName.includes('-'))
+                        //     isIndex = false
+                        // else
+                        // isIndex = true
+                    }
 
-function updateObject(data, doc, objectStore, database, array) {
-    return new Promise((resolve, reject) => {
-        let get = objectStore.get(doc._id)
-        get.onsuccess = function () {
-            let result = get.result
-            if (result || data.upsert == true) {
-                let modify = true
-                if (result && doc.modified && result.modified)
-                    if (doc.modified.on < result.modified.on)
-                        modify = false
-
-                if (modify) {
-                    if (data.method == 'update.object') {
-                        doc = dotNotationToObject(doc, get.result)
-
-                        if (data.updateName) {
-                            for (let key of Object.keys(data.updateName)) {
-                                let val = doc[key]
-                                delete doc[key]
-                                doc[data.updateName[key]] = val
+                    if (isIndex) {
+                        direction = data.$filter.sort[0].direction
+                        if (direction == 'desc')
+                            direction = 'prev'
+                        else
+                            direction = 'next'
+
+                        let indexNames = Array.from(objectStore.indexNames)
+                        let indexExist = indexNames.includes(indexName)
+                        if (!indexExist) {
+                            db.close()
+                            db = await processDatabase({ method: 'get.database', database, upgrade: true })
+                            transaction = db.transaction([array], 'readwrite');
+                            objectStore = transaction.objectStore(array);
+                            try {
+                                objectStore.createIndex(indexName, indexName, { unique: false })
+                            } catch (error) {
+                                // console.log(error)
                             }
                         }
+                        objectStore = objectStore.index(indexName);
+                    }
 
-                        if (data.deleteName) {
-                            for (let key of Object.keys(data.deleteName)) {
-                                delete doc[key]
-                            }
+                    if (data.$filter) {
+                        if (data.$filter.index)
+                            index = data.$filter.index
+                        if (data.$filter.limit)
+                            limit = data.$filter.limit
+                        if (limit)
+                            limit = index + limit;
+                    }
+                }
 
+                let cursor = await openCursor(objectStore, range, direction)
+                if (cursor) {
+                    let isMatch = true
+
+                    if (isFilter)
+                        isMatch = filter(objectStore, data[type][i], cursor.value)
+
+                    if (isMatch !== false) {
+                        let result
+                        if (data.method == 'create.object') {
+                            result = await add(objectStore, data[type][i])
+                        } else if (data.method == 'read.object') {
+                            result = await get(objectStore, data[type][i])
+                        } else if (data.method == 'update.object') {
+                            data[type][i] = dotNotationToObject(data[type][i], cursor.value)
+                            data[type][i] = createUpdate(data, data[type][i])
+                            result = await put(objectStore, data[type][i])
+                        } else if (data.method == 'delete.object') {
+                            result = await deleteObject(objectStore, data[type][i])
                         }
 
-                        let put = objectStore.put(doc);
+                        newData.push({ $storage: 'indexeddb', $database: database, $array: array, ...result })
+                    }
 
-                        put.onsuccess = function () {
-                            resolve(doc)
-                        };
+                    limit && limit == newData.length ? '' : cursor.continue();
 
-                        put.onerror = function () {
-                            errorHandler(data, put.error, database, array, doc)
-                            resolve(doc)
-                        };
+                } else if (index)
+                    newData = newData.slice(index)
+            }
+        }
+    } catch (error) {
+        errorHandler(data, error, database, array)
+    }
 
-                    }
+    db.close()
+}
 
-                    if (data.method == 'delete.object') {
-                        let deleteDoc = objectStore.delete(doc._id);
+function openCursor(objectStore, range, direction) {
+    return new Promise(async (resolve, reject) => {
+        const request = objectStore.openCursor(range, direction);// next, prev
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error)
+    });
+}
 
-                        deleteDoc.onsuccess = function () {
-                            resolve(doc)
-                        };
+function add(objectStore, object) {
+    return new Promise((resolve, reject) => {
+        const request = objectStore.add(object);
+        request.onsuccess = () => resolve(object);
+        request.onerror = () => reject(request.error);
+    });
+}
 
-                        deleteDoc.onerror = function () {
-                            errorHandler(data, deleteDoc.error, database, array, doc)
-                            resolve(doc)
-                        };
-                    }
+function get(objectStore, object) {
+    return new Promise((resolve, reject) => {
+        const request = objectStore.get(object._id);
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
 
-                } else {
-                    // TODO: handle if _id not found upsert
-                    errorHandler(data, 'doc in db is newer', database, array, doc)
-                    resolve(doc)
-                }
-            } else {
-                errorHandler(data, 'object doest not exist and upsert is not true', database, array, doc)
-                resolve(doc)
-            }
+function put(objectStore, object) {
+    return new Promise((resolve, reject) => {
+        const request = objectStore.put(object);
+        request.onsuccess = () => resolve(object);
+        request.onerror = () => reject(request.error);
+    });
+}
 
-        };
+function deleteObject(objectStore, object) {
+    return new Promise((resolve, reject) => {
+        const request = objectStore.delete(object._id);
+        request.onsuccess = () => resolve(object);
+        request.onerror = () => reject(request.error);
+    });
+}
 
-        get.onerror = function () {
-            errorHandler(data, get.error, database, array, doc)
-            resolve(doc)
-        };
 
-    })
-}
+function createUpdate(data, object) {
+    if (data.updateName) {
+        for (let key of Object.keys(data.updateName)) {
+            let val = object[key]
+            delete object[key]
+            object[data.updateName[key]] = val
+        }
+    }
 
-function readObject(data, database, array) {
-    return new Promise(async (resolve, reject) => {
+    if (data.deleteName) {
+        for (let key of Object.keys(data.deleteName)) {
+            delete object[key]
+        }
 
-        try {
-            let db = await processDatabase({ method: 'get.database', database })
-            let transaction = db.transaction([array], "readonly");
-            let objectStore = transaction.objectStore(array);
-
-            if (data.filter) {
-                let count = objectStore.count();
-                count.onsuccess = function () {
-                    data.filter.count = count.result
-                }
-            }
+    }
+    return object
+}
 
-            let isIndex = false
-            let indexName, direction;
-            if (data.filter && data.filter.sort && data.filter.sort[0] && data.filter.sort[0].name) {
-                indexName = data.filter.sort[0].name
-                // if (indexName.includes('-'))
-                //     isIndex = false
-                // else
-                // isIndex = true
-            }
+function filter(data, object, result) {
+    let isMatch = true;
 
-            if (isIndex) {
-                direction = data.filter.sort[0].direction
-                if (direction == 'desc')
-                    direction = 'prev'
-                else
-                    direction = 'next'
-
-                let indexNames = Array.from(objectStore.indexNames)
-                let indexExist = indexNames.includes(indexName)
-                if (!indexExist) {
-                    db.close()
-                    db = await processDatabase({ method: 'get.database', database, upgrade: true })
-                    transaction = db.transaction;
-                    objectStore = transaction.objectStore(array);
-                    try {
-                        objectStore.createIndex(indexName, indexName, { unique: false })
-                    } catch (error) {
-                        // console.log(error)
-                    }
-                }
-                objectStore = objectStore.index(indexName);
-            }
+    if (data.$filter || object.$filter) {
+        let count = objectStore.count();
+        count.onsuccess = function () {
+            data.$filter.count = count.result
+        }
+    }
 
-            let results = [], index = 0, limit
-            if (data.filter) {
-                if (data.filter.index)
-                    index = data.filter.index
-                if (data.filter.limit)
-                    limit = data.filter.limit
-                if (limit)
-                    limit = index + limit;
-            }
+    if (data.$filter) {
+        if (data.$filter.query)
+            isMatch = queryData(result, data.$filter.query);
+        if (isMatch && data.$filter.search)
+            isMatch = searchData(result, data.$filter.search);
+    }
 
-            const request = objectStore.openCursor(null, direction);
-            request.onsuccess = function () {
-                let cursor = request.result;
-                if (cursor) {
-                    let isFilter = true;
-                    let value = cursor.value;
-                    if (data.filter) {
-                        if (data.filter.query)
-                            isFilter = queryData(value, data.filter.query);
-                        if (isFilter && data.filter.search)
-                            isFilter = searchData(value, data.filter.search);
-                    }
-                    if (isFilter !== false)
-                        results.push(value)
-                    if (limit && limit == results.length) {
-                        results = results.slice(index, limit)
-                        resolve(results)
-                    } else
-                        cursor.continue();
-                } else {
-                    if (index)
-                        results = results.slice(index)
-                    resolve(results)
-                }
-            }
+    let modify = true
+    if (result && object.modified && result.modified)
+        if (object.modified.on < result.modified.on)
+            modify = false
 
-            request.onerror = function () {
-                errorHandler(data, request.error, database, array)
-                db.close()
-                resolve([])
-            };
+    return isMatch
+}
 
+function createData(data, newData, type) {
+    data.request = data[type] || {}
 
-            if (db && db.close)
-                db.close()
-            // return results
+    if (data.$filter && data.$filter.sort)
+        data[type] = sortData(newData, data.$filter.sort)
+    else
+        data[type] = newData
 
-        } catch (error) {
-            errorHandler(data, error, database, array)
-            resolve([])
-        }
-    });
+    if (data.returnLog) {
+        if (!data.log)
+            data.log = []
+        data.log.push(...data[type])
+    }
+
+    return data
 }
 
 function errorHandler(data, error, database, array) {
@@ -734,23 +687,6 @@ function errorHandler(data, error, database, array) {
         data.error = [error]
 }
 
-function createData(data, newData, type) {
-    data.request = data[type] || {}
-
-    if (data.filter && data.filter.sort)
-        data[type] = sortData(newData, data.filter.sort)
-    else
-        data[type] = newData
-
-    if (data.returnLog) {
-        if (!data.log)
-            data.log = []
-        data.log.push(...data[type])
-    }
-
-    return data
-}
-
 init();
 
-export default indexedDb
+export default { send }

package/test/documents.js

@@ -50,7 +50,7 @@ async function testDocuments() {
             // object: {
             //     _id
             // }
-            filter: {
+            $filter: {
                 query: [
                     { key: 'organization_id', value: "5ff747727005da1c272740ab" }
                 ]