@cocreate/indexeddb 1.10.20 → 1.11.0

package/src/index.js

@@ -1,98 +1,164 @@
 /********************************************************************************
- * Copyright (C) 2020 CoCreate LLC and others.
+ * Copyright (C) 2023 CoCreate and Contributors.
  *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- * SPDX-License-Identifier: MIT
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
  ********************************************************************************/
-import { ObjectId, dotNotationToObject, searchData, sortData, queryData } from '@cocreate/utils'
-import uuid from '@cocreate/uuid'
 
-let status = true;
+// Commercial Licensing Information:
+// For commercial use of this software without the copyleft provisions of the AGPLv3,
+// you must obtain a commercial license from CoCreate LLC.
+// For details, visit <https://cocreate.app/licenses/> or contact us at sales@cocreate.app.
 
-function createDatabase(data) {
-    return Database('createDatabase', data)
-}
+import { ObjectId, dotNotationToObject, searchData, sortData, queryData } from '@cocreate/utils'
 
-const readDatabase = (data) => {
-    return Database('readDatabase', data)
+// let status = true;
+let indexedDbFunction
+function init() {
+    // Check for support.
+    if (!('indexedDB' in window)) {
+        console.log("This browser doesn't support IndexedDB.");
+        setStatus(false);
+        return;
+    } else {
+        try {
+            indexedDB.databases()
+            if (window.CoCreateConfig && window.CoCreateConfig.indexeddb !== false)
+                setStatus(true)
+        } catch (e) {
+            setStatus(false);
+        }
+    }
 }
 
-const updateDatabase = (data) => {
-    return Database('updateDatabase', data)
+function setStatus(value) {
+    if (window.CoCreateConfig)
+        window.CoCreateConfig.indexeddb = value;
+    else
+        window.CoCreateConfig = { indexeddb: value };
+    if (!value) {
+        indexedDbFunction = indexedDb
+        indexedDb = value;
+    } else {
+        indexedDb = indexedDbFunction
+        indexedDbFunction = true
+    }
 }
 
-const deleteDatabase = (data) => {
-    return Database('deleteDatabase', data)
-}
+async function indexedDb(data) {
+    try {
+        let newData = [];
+
+        let type = data.method.split('.');
+        type = type[type.length - 1];
+
+        if (type === 'database')
+            await processDatabase(data, newData, type)
+        else {
+            if (data.request)
+                data[type] = data.request
+
+            if (!data['timeStamp'])
+                data['timeStamp'] = new Date().toISOString()
+
+            let databases = data.database;
+            if (!Array.isArray(databases))
+                databases = [databases]
+
+            let arrays = data.array;
+            if (!Array.isArray(arrays))
+                arrays = [arrays]
 
-const getDatabase = (data) => {
-    return Database('getDatabase', data)
+            for (let i = 0; i < databases.length; i++) {
+                let database = databases[i]
+                if (type === 'array') {
+                    await processArray(data, newData, database, '', type)
+                } else {
+                    for (let j = 0; j < arrays.length; j++) {
+                        if (type === 'index')
+                            await processIndex(data, newData, database, type)
+                        else if (type === 'object')
+                            await processObject(data, newData, database, arrays[j], type)
+                    }
+                }
+            }
+        }
+        return createData(data, newData, type)
+
+    } catch (error) {
+        errorHandler(data, error)
+    }
 }
 
 const dbVersion = new Map()
-const Database = (action, data) => {
+const processDatabase = (data, newData, type) => {
     return new Promise((resolve, reject) => {
-        let type = 'database'
-        let databaseArray = [];
-        if (!data) data = {}
+        if (!data)
+            data = {}
         if (data.request)
             data[type] = data.request
 
         if (!data['timeStamp'])
             data['timeStamp'] = new Date().toISOString()
 
-        if (action == 'readDatabase') {
+        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 (isFilter)
-                            databaseArray.push({ database, db: 'indexeddb' })
+                            newData.push({ storage: 'indexeddb', database })
                     } else
-                        databaseArray.push({ database, db: 'indexeddb' })
+                        newData.push({ storage: 'indexeddb', database })
                 }
 
-                resolve(createData(data, databaseArray, type))
+                resolve()
             })
         } else {
             let databases
-            if (action == 'updateDatabase')
-                databases = Object.keys(data.database).map((key) => [key, data.database[key]])
+            if (data.method == 'update.database')
+                databases = Object.keys(data.database)
             else
                 databases = data.database;
 
             if (!Array.isArray(databases))
                 databases = [databases]
 
-            let databasesLength = databases.length
-            for (let database of databases) {
-                if (action == 'updateDatabase')
-                    [database, value] = database
-
-                let openRequest;
-                switch (action) {
-                    case 'getDatabase':
-                    case 'createDatabase':
-                    case 'updateDatabase':
+            for (let i = 0; i < databases.length; i++) {
+                let openRequest, database = databases[i];
+                switch (data.method) {
+                    case 'get.database':
+                    case 'create.database':
+                    case 'update.database':
                         openRequest = indexedDB.open(database);
                         break;
-                    case 'deleteDatabase':
-                        openRequest = indexedDB.deleteDatabase(database);
+                    case 'delete.database':
+                        openRequest = indexedDB.deleteprocessDatabase(database);
                         break;
                     default:
-                        errorHandler(data, 'unknown action', database)
+                        errorHandler(data, 'unknown method', database)
                         resolve(data)
                 }
 
                 openRequest.onsuccess = function () {
                     let db = openRequest.result;
                     let dbs = [] // TODO: return an array of dbinstance??
-                    if (action == 'updateDatabase') {
-                        // TODO: open a cursor at database collection and save each collection and document at value
+                    if (data.method == 'update.database') {
+                        // TODO: open a cursor at database array and save each array and object at value
 
                         let objectStoreNames = Array.from(db.objectStoreNames)
-                        for (let collection of objectStoreNames) {
-                            let request = collection.openCursor();
+                        for (let array of objectStoreNames) {
+                            let request = array.openCursor();
 
                             request.onsuccess = function () {
                                 let cursor = request.result;
@@ -106,21 +172,20 @@ const Database = (action, data) => {
                             };
 
                             request.onerror = function () {
-                                errorHandler(data, request.error, database, collection)
+                                errorHandler(data, request.error, database, array)
                             };
 
                         }
 
-                    } else if (data.collection && data.collection.length) {
-                        let collections = data.collection;
-                        if (!Array.isArray(collections))
-                            collections = [collections]
-
-                        let collectionsLength = collections.length
-                        for (let collection of collections) {
+                    } else if (data.array && data.array.length) {
+                        let arrays = data.array;
+                        if (!Array.isArray(arrays))
+                            arrays = [arrays]
 
-                            let collectionExist = db.objectStoreNames.contains(collection)
-                            if (!collectionExist || collectionsLength == 1 && data.upgrade == true) {
+                        for (let j = 0; j < arrays.length; j++) {
+                            let array = arrays[j]
+                            let arrayExist = db.objectStoreNames.contains(array)
+                            if (!arrayExist || arrays.length == 1 && data.upgrade == true) {
                                 db.close()
 
                                 let version = dbVersion.get(database) || openRequest.result.version
@@ -130,24 +195,19 @@ const Database = (action, data) => {
                                 request.onupgradeneeded = function () {
                                     db = request.result;
 
-                                    if (!collectionExist) {
+                                    if (!arrayExist) {
                                         db = request.result;
                                         try {
-                                            db.createObjectStore(collection, { keyPath: '_id', autoIncrement: true });
+                                            db.createObjectStore(array, { keyPath: '_id', autoIncrement: true });
                                         } catch (error) {
-                                            errorHandler(data, error, database, collection)
+                                            errorHandler(data, error, database, array)
                                         }
                                     }
                                 };
 
                                 request.onsuccess = function () {
-                                    collectionsLength -= 1
-
-                                    if (!collectionsLength)
-                                        databasesLength -= 1
-
-                                    if (!databasesLength && !collectionsLength) {
-                                        if (action == 'getDatabase') {
+                                    if (databases.length - 1 === i && arrays.length - 1 === j) {
+                                        if (data.method == 'get.database') {
                                             let transaction = request.transaction
 
                                             if (data.upgrade == true && !transaction) {
@@ -171,25 +231,17 @@ const Database = (action, data) => {
                                 };
 
                                 request.onerror = function () {
-                                    errorHandler(data, request.error, database, collection)
-                                    collectionsLength -= 1
-
-                                    if (!collectionsLength)
-                                        databasesLength -= 1
-                                    if (!databasesLength && !collectionsLength) {
-                                        if (action == 'getDatabase')
+                                    errorHandler(data, request.error, database, array)
+                                    if (databases.length - 1 === i && arrays.length - 1 === j) {
+                                        if (data.method == 'get.database')
                                             resolve(request)
                                         else
                                             resolve(data)
                                     }
                                 };
                             } else {
-                                collectionsLength -= 1
-
-                                if (!collectionsLength)
-                                    databasesLength -= 1
-                                if (!databasesLength && !collectionsLength) {
-                                    if (action == 'getDatabase')
+                                if (databases.length - 1 === i && arrays.length - 1 === j) {
+                                    if (data.method == 'get.database')
                                         resolve(db)
                                     else
                                         resolve(data)
@@ -197,9 +249,8 @@ const Database = (action, data) => {
                             }
                         }
                     } else {
-                        databasesLength -= 1
-                        if (!databasesLength) {
-                            if (action == 'getDatabase') {
+                        if (databases.length - 1 === i) {
+                            if (data.method == 'get.database') {
                                 let transaction = openRequest.transaction
 
                                 if (data.upgrade == true && !transaction) {
@@ -212,12 +263,9 @@ const Database = (action, data) => {
                                     upgrade.onupgradeneeded = function () {
                                         resolve(upgrade)
                                     };
-
-                                } else {
+                                } else
                                     resolve(db)
-                                }
-                            }
-                            else
+                            } else
                                 resolve(data)
                         }
                     }
@@ -237,585 +285,261 @@ const Database = (action, data) => {
     });
 }
 
+async function processArray(data, newData, database, type) {
+    let db = await processDatabase({ method: 'get.database', database })
+    db.close()
+
+    let objectStoreNames = Array.from(db.objectStoreNames)
+    if (data.method == 'read.array') {
+        if (!data[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 (isFilter)
+                    newData.push({ name: objectStoreNames, storage: 'indexeddb', database })
+            } else
+                newData.push({ name: objectStoreNames[i], storage: 'indexeddb', database })
+        }
+    } else {
+        let arrays
+        if (data.method == 'update.array')
+            arrays = Object.keys(data[type])
+        else
+            arrays = data[type];
+        if (!Array.isArray(arrays))
+            arrays = [arrays]
+
+        for (let i = 0; i < arrays.length; i++) {
+            let error, array = arrays[i]
+
+            let arrayExist = db.objectStoreNames.contains(array)
+            if (arrayExist && data.method == 'create.array') {
+                error = 'array already exists'
+            } else {
+                if (!arrayExist && data.method == 'update.array')
+                    array = data[type][arrays[i]]
+
+                let db = await processDatabase({ method: 'get.database', database, array, upgrade: true })
+                if (arrayExist) {
+                    if (data.method == 'delete.array')
+                        db.result.deleteObjectStore(array)
+                    else if (data.method == 'update.array') {
+                        let transaction = db.transaction;
+                        let objectStore = transaction.objectStore(array);
+
+                        if (!objectStoreNames.includes(data[type][arrays[i]]))
+                            array = objectStore.name = data[type][arrays[i]];
+                        else
+                            error = 'An array with the new name already exist'
+                    }
+                } else if (data.method == 'update.array')
+                    error = 'array does not exists'
+            }
 
-function createCollection(data) {
-    return collection('createCollection', data)
-}
-
-function readCollection(data) {
-    return collection('readCollection', data)
-}
-
-function updateCollection(data) {
-    return collection('updateCollection', data)
-}
+            db.result.close()
 
-function deleteCollection(data) {
-    return collection('deleteCollection', data)
+            if (!error)
+                newData.push({ name: array, storage: 'indexeddb', database })
+            else
+                errorHandler(data, error, database)
+        }
+    }
 }
 
-const collection = (action, data) => {
-    return new Promise((resolve, reject) => {
-        let type = 'collection'
-        let collectionArray = [];
-
-        if (data.request)
-            data[type] = data.request
-
-        if (!data['timeStamp'])
-            data['timeStamp'] = new Date().toISOString()
-
-        let databases = data.database;
+async function processIndex(data, newData, database, array, type) {
+    let db = await processDatabase({ method: 'get.database', database })
+    let arrayExist = db.objectStoreNames.contains(array)
+    if (arrayExist) {
+        // ToDO: switch here to types
+        let transaction = db.transaction(array, "readonly");
+        let objectStore = transaction.objectStore(array);
+        let indexNames = Array.from(objectStore.indexNames)
+
+        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
+
+                newData.push({ name, storage: 'indexeddb', database, array })
+            }
+            db.close()
+        } else {
+            db.close()
+            let indexes
+            if (data.method == 'update.index')
+                indexes = Object.keys(data[type])
+            else
+                indexes = data[type];
 
-        if (!Array.isArray(databases))
-            databases = [databases]
-        let databasesLength = databases.length
-        for (let database of databases) {
-            let openRequest = indexedDB.open(database)
+            if (!Array.isArray(indexes))
+                indexes = [indexes]
 
-            openRequest.onsuccess = function () {
-                let db = openRequest.result;
-                db.close()
-                let objectStoreNames = Array.from(db.objectStoreNames)
-                if (action == 'readCollection') {
-                    if (!data[type])
-                        data[type] = []
-
-                    for (let collection of objectStoreNames) {
-                        if (data.filter && data.filter.query) {
-                            let isFilter = queryData({ name: collection }, data.filter.query)
-                            if (isFilter)
-                                collectionArray.push({ name: collection, db: 'indexeddb', database })
-                        } else
-                            collectionArray.push({ name: collection, db: 'indexeddb', database })
-                    }
+            for (let i = 0; i < indexes.length; i++) {
+                let error, index = indexes[i]
+                db = await processDatabase({ method: 'get.database', database, upgrade: true })
+                let transaction = db.transaction;
+                let objectStore = transaction.objectStore(array);
+                let indexExist = indexNames.includes(index)
 
-                    databasesLength -= 1
-                    if (!databasesLength) {
-                        resolve(createData(data, collectionArray, type))
-                    }
-
-                } else {
-                    let collections
-                    if (action == 'updateCollection')
-                        collections = Object.keys(data[type]).map((key) => [key, data[type][key]])
+                if (data.method == 'create.index') {
+                    if (!indexExist)
+                        objectStore.createIndex(index, index, { unique: false })
                     else
-                        collections = data[type];
-                    if (!Array.isArray(collections))
-                        collections = [collections]
-                    let collectionsLength = collections.length
-                    for (let collection of collections) {
-                        let value
-                        if (action == 'updateCollection')
-                            [collection, value] = collection
-                        let collectionExist = db.objectStoreNames.contains(collection)
-                        if (
-                            collectionExist && ['updateCollection', 'deleteCollection'].includes(action) ||
-                            !collectionExist && ['createCollection', 'updateCollection'].includes(action)
-                        ) {
-                            getDatabase({ database, collection, upgrade: true }).then((db) => {
-                                if (collectionExist && action == 'updateCollection') {
-                                    let transaction = db.transaction;
-                                    let objectStore = transaction.objectStore(collection);
-
-                                    let valueExist = objectStoreNames.includes(value)
-                                    if (!valueExist) {
-                                        objectStore.name = value;
-                                    }
-                                    else
-                                        errorHandler(data, 'collection does not exist', database)
-
-                                    db.result.close()
-
-                                    collectionArray.push({ name: value, db: 'indexeddb', database })
-                                    collectionsLength -= 1
-
-                                    if (!collectionsLength)
-                                        databasesLength -= 1
-
-                                    if (!databasesLength && !collectionsLength) {
-                                        resolve(createData(data, collectionArray, type))
-                                    }
-
-                                } else {
-                                    db = db.result
-
-                                    if (action == 'deleteCollection') {
-                                        db.deleteObjectStore(collection)
-                                    }
-
-                                    db.close()
-
-                                    collectionArray.push({ name: collection, db: 'indexeddb', database })
-                                    collectionsLength -= 1
-
-                                    if (!collectionsLength)
-                                        databasesLength -= 1
-
-                                    if (!databasesLength && !collectionsLength) {
-                                        resolve(createData(data, collectionArray, type))
-                                    }
-
-                                }
-                            }, (error) => {
-                                errorHandler(data, error, database)
-                            })
-
-                        } else {
-                            collectionArray.push({ name: collection, db: 'indexeddb', database })
-                            collectionsLength -= 1
-
-                            if (!collectionsLength)
-                                databasesLength -= 1
-
-                            if (!databasesLength && !collectionsLength) {
-                                resolve(createData(data, collectionArray, type))
-                            }
-                        }
-
+                        error = 'index already exist'
+                } else if (indexExist) {
+                    if (data.method == 'delete.index')
+                        objectStore.deleteIndex(index)
+                    else if (data.method == 'update.index' && !indexNames.includes(data[type][indexes[i]])) {
+                        if (!indexNames.includes(data[type][indexes[i]])) {
+                            let indexObj = objectStore.index(index);
+                            index = indexObj.name = data[type][indexes[i]];
+                        } else
+                            error = 'new index name already exist'
                     }
+                } else
+                    error = 'index does not exist'
 
-                }
-
-            };
-
-            openRequest.onerror = function () {
-                errorHandler(data, openRequest.error, database)
-                databasesLength -= 1
+                if (!error)
+                    newData.push({ name: index, storage: 'indexeddb', database, array })
+                else
+                    errorHandler(data, error, database, array)
 
-                if (!databasesLength) {
-                    resolve(data)
-                }
-            };
+                db.result.close()
+            }
         }
-    }, (error) => {
-        errorHandler(data, error)
-    });
-}
-
-
-function createIndex(data) {
-    return index('createIndex', data)
-}
-
-function readIndex(data) {
-    return index('readIndex', data)
-}
-
-function updateIndex(data) {
-    return index('updateIndex', data)
-}
-
-function deleteIndex(data) {
-    return index('deleteIndex', data)
+    }
 }
 
-const index = (action, data) => {
-    return new Promise((resolve, reject) => {
-        let type = 'index'
-        let indexArray = [];
-
-        if (data.request)
-            data[type] = data.request
-
-        if (!data['timeStamp'])
-            data['timeStamp'] = new Date().toISOString()
-
-        let databases = data.database;
-        if (!Array.isArray(databases))
-            databases = [databases]
-
-        let collections = data.collection;
-        if (!Array.isArray(collections))
-            collections = [collections]
-
-        let databasesLength = databases.length
-        for (let database of databases) {
-            let collectionsLength = collections.length
-            for (let collection of collections) {
-                getDatabase({ database }).then((db) => {
-                    let objectStoreNames = Array.from(db.objectStoreNames)
-                    if (objectStoreNames.includes(collection)) {
-                        let transaction = db.transaction(collection, "readonly");
-                        let objectStore = transaction.objectStore(collection);
-                        let indexNames = Array.from(objectStore.indexNames)
-
-                        if (action == 'readIndex') {
-                            for (let index of indexNames) {
-                                if (data.filter && data.filter.query) {
-                                    let isFilter = queryData({ name: index }, data.filter.query)
-                                    if (isFilter)
-                                        indexArray.push({ name: index, db: 'indexeddb', database, collection })
-                                } else
-                                    indexArray.push({ name: index, db: 'indexeddb', database, collection })
-                            }
-                            collectionsLength -= 1
-                            db.close()
-
-                            if (!collectionsLength)
-                                databasesLength -= 1
-
-                            if (!databasesLength && !collectionsLength)
-                                resolve(createData(data, indexArray, type))
-
-                        } else {
-                            db.close()
-                            let indexes
-                            if (action == 'updateIndex')
-                                indexes = Object.keys(data[type]).map((key) => [key, data[type][key]])
-                            else
-                                indexes = data[type];
-                            if (!Array.isArray(indexes))
-                                indexes = [indexes]
-
-                            let indexesLength = indexes.length
-                            for (let index of indexes) {
-
-                                getDatabase({ database, upgrade: true }).then((db2) => {
-                                    let transaction = db2.transaction;
-                                    let objectStore = transaction.objectStore(collection);
-
-                                    let value
-                                    if (action == 'updateIndex')
-                                        [index, value] = index
-
-                                    let indexExist = indexNames.includes(index)
-
-                                    if (action == 'createIndex') {
-                                        if (!indexExist) {
-                                            objectStore.createIndex(index, index, { unique: false })
-                                            indexArray.push({ name: index, db: 'indexeddb', database, collection })
-                                        }
-                                        else
-                                            errorHandler(data, 'index exist', database, collection)
-                                    }
-                                    if (action == 'updateIndex') {
-                                        let valueExist = indexNames.includes(value)
-                                        let indexObj = objectStore.index(index);
-                                        if (indexExist && !valueExist) {
-                                            indexObj.name = value;
-                                            indexArray.push({ name: value, db: 'indexeddb', database, collection })
-                                        }
-                                        else
-                                            errorHandler(data, 'index does not exist', database, collection)
-
-                                    }
-                                    if (action == 'deleteIndex') {
-                                        if (indexExist) {
-                                            objectStore.deleteIndex(index)
-                                            indexArray.push({ name: index, db: 'indexeddb', database, collection })
-                                        }
-                                        else
-                                            errorHandler(data, 'index does not exist', database, collection)
-                                    }
-                                    db2.result.close()
+async function processObject(data, newData, database, array, type) {
+    let db = await processDatabase({ method: 'get.database', database })
+    let filteredObjects
+    let arrayExist = db.objectStoreNames.contains(array)
+    if (arrayExist) {
+        if (data.filter || data.method == 'read.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)) {
+            db.close()
+            filteredObjects = await readObject(data, database, array)
+            db = processDatabase({ method: 'get.database', database })
+        }
+    }
 
-                                    indexesLength -= 1
+    let transaction, objectStore
+    if (array && db) {
+        transaction = db.transaction([array], "readwrite");
+        objectStore = transaction.objectStore(array);
+    }
 
-                                    if (!indexesLength)
-                                        collectionsLength -= 1
+    let objects = []
 
-                                    if (!collectionsLength)
-                                        databasesLength -= 1
+    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]})
 
-                                    if (!databasesLength && !collectionsLength && !indexesLength) {
-                                        resolve(createData(data, indexArray, 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] })
 
-                    } else {
-                        db.close()
-                        errorHandler(data, `collection: ${collection} does not exist`, database, collection)
-                        resolve(data)
-                    }
-                });
+        }
 
+        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)
             }
         }
 
-    }, (error) => {
-        errorHandler(data, error)
-    });
-}
-
-function createDocument(data) {
-    return document('createDocument', data)
-}
-
-function readDocument(data) {
-    return document('readDocument', data)
-}
-
-function updateDocument(data) {
-    return document('updateDocument', data)
-}
-
-function deleteDocument(data) {
-    return document('deleteDocument', data)
-}
-
-
-const document = (action, data) => {
-    return new Promise((resolve, reject) => {
-        let type = 'document'
-        let documents = []
-
-        if (data.request)
-            data[type] = data.request
-
-        if (data.document && !Array.isArray(data.document))
-            data.document = [data.document]
-
-        if (!data['timeStamp'])
-            data['timeStamp'] = new Date().toISOString()
-
-        let databases = data.database;
-        if (!Array.isArray(databases))
-            databases = [databases]
-
-        let collections = data.collection;
-        if (!Array.isArray(collections))
-            collections = [collections]
-
-        let databasesLength = databases.length
-        for (let database of databases) {
-            getDatabase({ database }).then((db) => {
-                let collectionsLength = collections.length
-                for (let collection of collections) {
-                    let collectionExist = db.objectStoreNames.contains(collection)
-                    if (!collectionExist) {
-                        db.close()
-                        getDatabase({ database, collection }).then((db) => {
-                            if (data.filter || action == 'readDocument' && (!data.document || !data.document.length)) {
-                                db.close()
-                                readDocuments(data, database, collection).then((filterDocs) => {
-                                    getDatabase({ database }).then((db) => {
-                                        let transaction = db.transaction([collection], "readwrite");
-                                        let objectStore = transaction.objectStore(collection);
-
-                                        runDocs({ action, data, objectStore, documents, filterDocs, database, collection, type }).then(() => {
-                                            db.close()
-                                            collectionsLength -= 1
-
-                                            if (!collectionsLength)
-                                                databasesLength -= 1
-
-                                            if (!databasesLength && !collectionsLength) {
-                                                resolve(createData(data, documents, type))
-                                            }
-                                        })
-                                    })
-
-                                })
-                            } else {
-                                let transaction = db.transaction([collection], "readwrite");
-                                let objectStore = transaction.objectStore(collection);
-
-                                runDocs({ action, data, objectStore, documents, database, collection, type }).then(() => {
-                                    db.close()
-                                    collectionsLength -= 1
-
-                                    if (!collectionsLength)
-                                        databasesLength -= 1
-
-                                    if (!databasesLength && !collectionsLength) {
-                                        resolve(createData(data, documents, type))
-                                    }
-                                })
-                            }
-
-                        }).catch((error) => {
-                            errorHandler(data, { message: error, data }, database)
-                            collectionsLength -= 1
-
-                            if (!collectionsLength)
-                                databasesLength -= 1
-
-                            if (!databasesLength && !collectionsLength)
-                                resolve(createData(data, documents, type))
-
-                        })
-
-                    } else {
-                        if (data.filter || action == 'readDocument' && (!data.document || !data.document.length)) {
-
-                            db.close()
-                            readDocuments(data, database, collection).then((filterDocs) => {
-                                getDatabase({ database }).then((db) => {
-                                    let transaction = db.transaction([collection], "readwrite");
-                                    let objectStore = transaction.objectStore(collection);
-
-                                    runDocs({ action, data, objectStore, documents, filterDocs, database, collection, type }).then(() => {
-                                        db.close()
-                                        collectionsLength -= 1
-
-                                        if (!collectionsLength)
-                                            databasesLength -= 1
-
-                                        if (!databasesLength && !collectionsLength) {
-                                            resolve(createData(data, documents, type))
-                                        }
-                                    })
-                                })
-                            })
-                        } else {
-                            let transaction = db.transaction([collection], "readwrite");
-                            let objectStore = transaction.objectStore(collection);
-
-                            runDocs({ action, data, objectStore, documents, database, collection, type }).then(() => {
-                                db.close()
-                                collectionsLength -= 1
-
-                                if (!collectionsLength)
-                                    databasesLength -= 1
-                                if (!databasesLength && !collectionsLength) {
-                                    resolve(createData(data, documents, type))
-                                }
-                            })
-                        }
-                    }
-                }
-
-            }).catch((error) => {
-                errorHandler(data, { message: error, data }, database)
+        if (data.method == 'delete.object')
+            objects.push(...filteredObjects)
+    }
 
-                databasesLength -= 1
+    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) {
+                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)
+        }
 
-                if (!databasesLength)
-                    resolve(createData(data, documents, type))
-            })
+    }
 
-        }
-    })
+    db.close()
 }
 
-function runDocs({ action, data, objectStore, documents, filterDocs, database, collection, type }) {
+function addGet(data, newData, database, array, object, objectStore, operator) {
     return new Promise((resolve, reject) => {
-        let docs = []
-
-        if (Array.isArray(data[type]))
-            docs.push(...data[type]);
-        // else if (data[type] != undefined && action == 'createDocument')
-        //     docs.push(data[type])
-        // else if (data[type] != undefined)
-        //     docs.push({...data[type]})
-
-
-        if (filterDocs && filterDocs.length) {
-            if (action == 'readDocument') {
-                for (let i = 0; i < filterDocs.length; i++)
-                    documents.push({ db: 'indexeddb', database, collection, ...filterDocs[i] })
-
-            }
+        let request = objectStore[operator](object)
 
-            if (action == 'updateDocument') {
-                let updateData = docs[0];
-                if (updateData)
-                    docs.shift();
-                for (let filterDoc of filterDocs) {
-                    filterDoc = dotNotationToObject(updateData, filterDoc)
-                    docs.push(filterDoc)
-                }
+        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 (action == 'deleteDocument')
-                docs.push(...filterDocs)
-        }
-
-        let docsLength = docs.length
-
-        if (docsLength > 0) {
-            for (let doc of docs) {
-                // TODO deDuplcate document_id per collection
-                delete doc.storage
-                delete doc.database
-                delete doc.collection
-
-                if (action == 'updateDocument' || action == 'deleteDocument') {
-                    if (doc._id) {
-                        if (data.organization_id)
-                            doc['organization_id'] = data.organization_id
-                        doc['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-
-                        updateDoc(action, data, doc, objectStore, database, collection).then((doc) => {
-                            doc.storage = 'indexeddb'
-                            doc.database = database
-                            doc.collection = collection
-                            documents.push(doc)
-                            docsLength -= 1
-                            if (!docsLength) {
-                                resolve()
-                            }
-                        })
-                    } else {
-                        docsLength -= 1
-                        if (!docsLength)
-                            resolve()
-                    }
-                } else {
-                    let request;
-                    if (action == 'createDocument') {
-                        if (!doc._id)
-                            doc['_id'] = ObjectId()
-                        doc = dotNotationToObject(doc)
-
-                        if (data.organization_id)
-                            doc['organization_id'] = data.organization_id
-                        doc['created'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-                        request = objectStore.add(doc);
-                    }
-
-                    if (action == 'readDocument') {
-                        if (action == 'readDocument' && doc._id)
-                            request = objectStore.get(doc._id);
-                        else {
-                            docsLength -= 1
-                            errorHandler(data, { message: 'requires _id', document: doc }, database, objectStore.name)
-                            if (!docsLength) {
-                                resolve()
-                            }
-                        }
-                    }
-
-                    request.onsuccess = function () {
-                        if (request.result) {
-                            if (action == 'readDocument')
-                                doc = request.result
-                            doc.storage = 'indexeddb'
-                            doc.database = database
-                            doc.collection = collection
-
-                            documents.push(doc)
-                        }
-                        docsLength -= 1
-                        if (!docsLength) {
-                            resolve()
-                        }
-                    };
-
-                    request.onerror = function () {
-                        errorHandler(data, { message: request.error, document: doc }, database, objectStore.name)
-                        resolve()
-                    };
-                }
-            }
-        } else {
+        request.onerror = function () {
+            errorHandler(data, { message: request.error, object }, database, objectStore.name)
             resolve()
-        }
-    }, (error) => {
-        errorHandler(data, { message: error, document: doc }, database, objectStore.name)
-    })
+        };
+
+    });
 }
 
-function updateDoc(action, data, doc, objectStore, database, collection) {
+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
@@ -824,7 +548,7 @@ function updateDoc(action, data, doc, objectStore, database, collection) {
                         modify = false
 
                 if (modify) {
-                    if (action == 'updateDocument') {
+                    if (data.method == 'update.object') {
                         doc = dotNotationToObject(doc, get.result)
 
                         if (data.updateName) {
@@ -849,13 +573,13 @@ function updateDoc(action, data, doc, objectStore, database, collection) {
                         };
 
                         put.onerror = function () {
-                            errorHandler(data, put.error, database, collection, doc)
+                            errorHandler(data, put.error, database, array, doc)
                             resolve(doc)
                         };
 
                     }
 
-                    if (action == 'deleteDocument') {
+                    if (data.method == 'delete.object') {
                         let deleteDoc = objectStore.delete(doc._id);
 
                         deleteDoc.onsuccess = function () {
@@ -863,270 +587,156 @@ function updateDoc(action, data, doc, objectStore, database, collection) {
                         };
 
                         deleteDoc.onerror = function () {
-                            errorHandler(data, deleteDoc.error, database, collection, doc)
+                            errorHandler(data, deleteDoc.error, database, array, doc)
                             resolve(doc)
                         };
                     }
 
                 } else {
                     // TODO: handle if _id not found upsert
-                    errorHandler(data, 'doc in db is newer', database, collection, doc)
+                    errorHandler(data, 'doc in db is newer', database, array, doc)
                     resolve(doc)
                 }
             } else {
-                errorHandler(data, 'document doest not exist and upsert is not true', database, collection, doc)
+                errorHandler(data, 'object doest not exist and upsert is not true', database, array, doc)
                 resolve(doc)
             }
 
         };
 
         get.onerror = function () {
-            errorHandler(data, get.error, database, collection, doc)
+            errorHandler(data, get.error, database, array, doc)
             resolve(doc)
         };
 
     })
 }
 
-const readDocuments = (data, database, collection) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(database);
-
-        openRequest.onsuccess = function () {
-            let db = openRequest.result;
-            try {
-                let transaction = db.transaction([collection], "readonly");
-                let objectStore = transaction.objectStore(collection);
-
-                if (data.filter) {
-                    let count = objectStore.count();
-                    count.onsuccess = function () {
-                        data.filter.count = count.result
-                    }
-                }
+function readObject(data, database, array) {
+    return new Promise(async (resolve, reject) => {
 
-                let isIndex = false
-                let indexName;
-                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
+        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
                 }
+            }
 
-                if (isIndex) {
-                    let 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()
-                        getDatabase({ database, upgrade: true }).then((db2) => {
-                            let transaction = db2.transaction;
-                            let objectStore = transaction.objectStore(collection);
-                            try {
-                                objectStore.createIndex(indexName, indexName, { unique: false })
-                            } catch (error) {
-                                // console.log(error)
-                            }
-                            const indexStore = objectStore.index(indexName);
-
-                            readDocs(data, database, collection, indexStore, direction).then((results) => {
-                                if (db2 && db2.close)
-                                    db2.close()
-                                resolve(results)
-                            })
-                        })
-                    } else {
-                        const indexStore = objectStore.index(indexName);
-                        readDocs(data, database, collection, indexStore, direction).then((results) => {
-                            db.close()
-                            resolve(results)
-                        })
+            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
+            }
+
+            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)
                     }
-                } else {
-                    readDocs(data, database, collection, objectStore).then((results) => {
-                        db.close()
-                        resolve(results)
-                    })
                 }
-            } catch (error) {
-                errorHandler(data, error, database)
-                db.close()
-                resolve([])
-                return
+                objectStore = objectStore.index(indexName);
             }
 
-        };
-
-        openRequest.onerror = function () {
-            errorHandler(data, openRequest.error)
-            resolve(data)
-        };
-    })
-}
-
-async function readDocs(data, database, collection, objectStore, direction) {
-    return new Promise((resolve, reject) => {
-
-        let results = [], index = 0, limit
-        if (data.filter) {
-            if (data.filter.startIndex)
-                index = data.filter.startIndex
-            if (data.filter.limit)
-                limit = data.filter.limit
-            if (limit)
-                limit = index + limit;
-        }
+            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;
+            }
 
-        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)
+            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)
-                } else
-                    cursor.continue();
-            } else {
-                if (index)
-                    results = results.slice(index)
-                resolve(results)
+                }
             }
-        }
-
-        request.onerror = function () {
-            errorHandler(data, request.error, database, collection)
-            db.close()
-            resolve([])
-        };
 
-    });
-}
+            request.onerror = function () {
+                errorHandler(data, request.error, database, array)
+                db.close()
+                resolve([])
+            };
 
-async function generateDB(organization = { document: {} }, user = { document: {} }) {
-    const organization_id = organization.document._id || ObjectId();
-    const defaultKey = organization.document.key || uuid.generate();
-    const user_id = user.document._id || ObjectId();
 
-    let apiKey = await readDocument({ database: organization_id, collection: 'keys', organization_id })
-    if (apiKey && apiKey.document && apiKey.document[0])
-        return
+            if (db && db.close)
+                db.close()
+            // return results
 
-    try {
-        // Create organization 
-        organization.database = organization_id
-        organization.collection = 'organizations'
-        organization.document._id = organization_id
-        organization.document.name = organization.document.name || 'untitiled'
-        organization.organization_id = organization_id
-        createDocument(organization);
-
-        // Create user
-        user.database = organization_id
-        user.collection = 'users'
-        user.document._id = user_id
-        user.document.firstname = user.document.firstname || 'untitiled'
-        user.document.lastname = user.document.lastname || 'untitiled'
-        user.organization_id = organization_id
-        createDocument(user);
-
-        // Create default key
-        let key = {
-            database: organization_id,
-            collection: 'keys',
-            document: {
-                _id: ObjectId(),
-                type: "key",
-                key: defaultKey,
-                actions: {
-                    signIn: true,
-                    signUp: true
-                },
-                default: true
-            },
-            organization_id
+        } catch (error) {
+            errorHandler(data, error, database, array)
+            resolve([])
         }
-        createDocument(key);
-
-        // Create role
-        let role_id = ObjectId();
-        let role = {
-            database: organization_id,
-            collection: 'keys',
-            document: {
-                _id: role_id,
-                type: "role",
-                name: "admin",
-                admin: "true"
-            },
-            organization_id
-        };
-        createDocument(role);
-
-        // Create user key
-        let userKey = {
-            database: organization_id,
-            collection: 'keys',
-            document: {
-                _id: ObjectId(),
-                type: "user",
-                key: user_id,
-                collection: 'users', // could be any collection
-                roles: [role_id],
-                email: user.document.email,
-                password: user.document.password || btoa('0000')
-            },
-            organization_id
-        };
-        createDocument(userKey);
-
-        return [organization, key, user, role, userKey]
-
-    } catch (error) {
-        return false
-    }
+    });
 }
 
-function errorHandler(data, error, database, collection) {
+function errorHandler(data, error, database, array) {
     if (typeof error == 'object')
         error['storage'] = 'indexeddb'
     else
-        error = { db: 'indexeddb', message: error }
+        error = { storage: 'indexeddb', message: error }
 
     if (database)
         error['database'] = database
-    if (collection)
-        error['collection'] = collection
+    if (array)
+        error['array'] = array
     if (data.error)
         data.error.push(error)
     else
         data.error = [error]
-
 }
 
-function createData(data, array, type) {
+function createData(data, newData, type) {
     data.request = data[type] || {}
 
     if (data.filter && data.filter.sort)
-        data[type] = sortData(array, data.filter.sort)
+        data[type] = sortData(newData, data.filter.sort)
     else
-        data[type] = array
+        data[type] = newData
 
     if (data.returnLog) {
         if (!data.log)
@@ -1137,59 +747,6 @@ function createData(data, array, type) {
     return data
 }
 
-
-function init() {
-    // Check for support.
-    if (!('indexedDB' in window)) {
-        console.log("This browser doesn't support IndexedDB.");
-        setStatus(false);
-        return;
-    } else {
-        try {
-            indexedDB.databases()
-            if (window.CoCreateConfig && window.CoCreateConfig.indexeddb !== false)
-                setStatus(true)
-        } catch (e) {
-            setStatus(false);
-        }
-    }
-}
-
-function setStatus(value) {
-    if (window.CoCreateConfig)
-        window.CoCreateConfig.indexeddb = value;
-    else
-        window.CoCreateConfig = { indexeddb: value };
-
-    status = value;
-}
-
-
 init();
 
-export default {
-    status,
-    ObjectId,
-    getDatabase,
-    createDatabase,
-    readDatabase,
-    updateDatabase,
-    deleteDatabase,
-
-    createCollection,
-    readCollection,
-    updateCollection,
-    deleteCollection,
-
-    createIndex,
-    readIndex,
-    updateIndex,
-    deleteIndex,
-
-    createDocument,
-    readDocument,
-    updateDocument,
-    deleteDocument,
-
-    generateDB
-};
+export default indexedDb