@cocreate/indexeddb 1.2.11 → 1.3.0

package/src/index.js

@@ -7,632 +7,868 @@
 import {dotNotationToObject} from '@cocreate/utils'
 import {searchData, sortData, queryData} from '@cocreate/filter/src/filter.js'
 
-const createDatabase = (data) => {
-    return new Promise((resolve, reject) => {
-        
-        let openRequest = indexedDB.open(data.database);
+function createDatabase(data){
+    return Database('createDatabase', data)
+}
 
-        openRequest.onsuccess = function() {
-            resolve(openRequest.result)
-        };
+const readDatabase = () => {
+    return Database('readDatabase', data)
+}
 
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
+const updateDatabase = (data) => {
+    return Database('updateDatabase', data)
+}
 
-    }, (err) => {
-        console.log(err);
-    });
+const deleteDatabase = (data) => {
+    return Database('deleteDatabase', data)
 }
 
-const readDatabase = (data) => {
+const getDatabase = (data) => {
+    return Database('getDatabase', data)
+}
+
+const dbVersion = new Map()
+const Database = (action, data) => {
     return new Promise((resolve, reject) => {
+        let type = 'database'
+        let databaseArray = [];
 
-        let openRequest = indexedDB.open(data.database);
+        if (data.request)
+            data[type] = data.request
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            if (data.upgrade == true) { 
-                let version = openRequest.result.version
-                db.close()
-                
-                let request = indexedDB.open(data.database, Number(version += 1));
-                request.onupgradeneeded = function() {
-                    db = request.result
-                };
+        if (!data['timeStamp'])
+            data['timeStamp'] = new Date().toISOString()
+
+        if (action == 'readDatabase') {
+            indexedDB.databases().then((databases) => {
+                data.databases = databases
+                resolve(data)
+            })
+        } else {
+            let databases
+            if (action == 'updateDatabase')
+                databases = Object.entries(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':
+                        openRequest = indexedDB.open(database);
+                        break;
+                    case 'deleteDatabase':
+                        openRequest = indexedDB.deleteDatabase(database);
+                        break;
+                    default:
+                        errorHandler(data, 'unknown action', 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
+
+                        let objectStoreNames = Array.from(db.objectStoreNames)
+                        for (let collection of objectStoreNames) {
+                            let request = collection.openCursor();
+            
+                            request.onsuccess = function() {
+                                let cursor = request.result;
+                                if (cursor) {
+                                    let value = cursor.value;
+                                   
+                                    cursor.continue();
+                                } else {
+                                    // -1
+                                }
+                            };
+                            
+                            request.onerror = function() {
+                                errorHandler(data, request.error, database, collection)
+                            };
+    
+                        }
         
-                request.onsuccess = function() {
-                    resolve(db)
-                };
+                    } 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) {
+        
+                            let collectionExist = db.objectStoreNames.contains(collection)
+                            if (!collectionExist || collectionsLength == 1 && data.upgrade == true) {
+                                db.close()
+ 
+                                let version = dbVersion.get(database) || openRequest.result.version
+                                let request = indexedDB.open(database, Number(version += 1));
+                                dbVersion.set(database, version)
             
-                request.onerror = function() {
-                    reject(request.error)
-                };
+                                request.onupgradeneeded = function() {
+                                    db = request.result;
+
+                                    if (!collectionExist) {
+                                        db = request.result;
+                                        try {
+                                            db.createObjectStore(collection, {keyPath: '_id', autoIncrement: true});
+                                        } catch (error) {
+                                            errorHandler(data, error, database, collection)
+                                        }
+                                    }
+                                };
+                        
+                                request.onsuccess = function() {                                        
+                                    collectionsLength -= 1
+
+                                    if (!collectionsLength)
+                                        databasesLength -= 1
+
+                                    if (!databasesLength && !collectionsLength) {
+                                        if (action == 'getDatabase') {
+                                            let transaction = request.transaction
+                                            
+                                            if (data.upgrade == true && !transaction) {
+                                                request.result.close()
+
+                                                let version = dbVersion.get(database) || openRequest.result.version
+                                                let upgrade = indexedDB.open(database, Number(version += 1));
+                                                dbVersion.set(database, version)
+                            
+                                                upgrade.onupgradeneeded = function() {
+                                                    resolve(upgrade)
+                                                };
+
+                                            } else {
+                                                resolve(request.result)
+                                            }
+                                        }
+                                        else 
+                                            resolve(data)
+                                    }
+                                };
+                            
+                                request.onerror = function() {
+                                    errorHandler(data, request.error, database, collection)
+                                    collectionsLength -= 1
+
+                                    if (!collectionsLength)
+                                        databasesLength -= 1
+                                    if (!databasesLength && !collectionsLength) {
+                                        if (action == 'getDatabase')
+                                            resolve(request)
+                                        else
+                                            resolve(data)
+                                    }
+                                };
+                            } else {
+                                collectionsLength -= 1
+
+                                if (!collectionsLength)
+                                    databasesLength -= 1
+                                if (!databasesLength && !collectionsLength) {
+                                    if (action == 'getDatabase')
+                                        resolve(db)
+                                    else
+                                        resolve(data)
+                                }
+                            }
+                        }
+                    } else {
+                        databasesLength -= 1
+                        if (!databasesLength) {
+                            if (action == 'getDatabase') {
+                                let transaction = openRequest.transaction
+                                            
+                                if (data.upgrade == true && !transaction) {                                    
+                                    db.close()
+
+                                    let version = dbVersion.get(database) || openRequest.result.version
+                                    let upgrade = indexedDB.open(database, Number(version += 1));
+                                    dbVersion.set(database, version)
+                
+                                    upgrade.onupgradeneeded = function() {
+                                        resolve(upgrade)
+                                    };
+     
+                                } else {
+                                    resolve(db)
+                                }
+                            }
+                            else
+                                resolve(data)
+                        }
+                    }
         
-            } else {
-                resolve(db)
-            }
-        };
+                }
 
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
+                openRequest.onerror = function() {
+                    errorHandler(data, openRequest.error, database)
+                    resolve(data)
+                };
 
-    }, (err) => {
-        console.log(err);
-    });
-}
+            }
+        }
 
-const readDatabases = () => {
-    return new Promise((resolve, reject) => {
-        indexedDB.databases().then((databases) => {
-            resolve(databases)
-        })
     }, (err) => {
-        console.log(err);
+        errorHandler(data, err)
     });
 }
 
-const updateDatabase = (data) => {
-    return new Promise((resolve, reject) => {
-        
-        let openRequest = indexedDB.open(data.database);
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            if (data.newDatabase) { 
-                // function to clone db with new name
-            } else {
-                resolve(db)
-            }
-        };
+function createCollection(data){
+    return collection('createCollection', data)
+}
 
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
+function readCollection(data) {
+    return collection('readCollection', data)
+}
 
-    }, (err) => {
-        console.log(err);
-    });
+function updateCollection(data) {
+    return collection('updateCollection', data)
 }
 
-const deleteDatabase = (data) => {
+function deleteCollection(data) {
+    return collection('deleteCollection', data)
+}
+
+const collection = (action, data) => {
     return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.deleteDatabase(data.database);
+        let type = 'collection'
+        let collectionArray = [];
 
-        openRequest.onsuccess = function() {
-            resolve(openRequest.result);
-        };
+        if (data.request)
+            data[type] = data.request
 
-        openRequest.onerror = function() {
-            reject(openRequest.error);
-        };
+        if (!data['timeStamp'])
+            data['timeStamp'] = new Date().toISOString()
 
-    }, (err) => {
-        console.log(err);
-    });
-}
+        let databases = data.database;  
 
-const database = (data) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
+        if (!Array.isArray(databases))
+            databases = [databases]
+        let databasesLength = databases.length
+        for (let database of databases) {
+            let openRequest = indexedDB.open(database)
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            let collectionExist = db.objectStoreNames.contains(data.collection)
-            if (data.collection && !collectionExist || data.upgrade == true) { 
-                let version = openRequest.result.version
+            openRequest.onsuccess = function() {
+                let db = openRequest.result;
                 db.close()
-                
-                let request = indexedDB.open(data.database, Number(version += 1));
-                request.onupgradeneeded = function() {
-                    if (!collectionExist) {
-                        db = request.result;
-                        db.createObjectStore(data.collection, {keyPath: '_id', autoIncrement: true});
+                let objectStoreNames = Array.from(db.objectStoreNames)
+                if (action == 'readCollection') {
+                    if (!data[type])
+                        data[type] = []
+                    
+                    for (let collection of Array.from(objectStoreNames)){
+                        collectionArray.push({name: collection, db: 'indexeddb', database})
                     }
-                };
-        
-                request.onsuccess = function() {
-                    resolve(db)
-                };
-            
-                request.onerror = function() {
-                    reject(request.error)
-                };
-        
-            } else {
-                resolve(db)
-            }
-        };
-
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
 
-    }, (err) => {
-        console.log(err);
-    });
-}
+                    databasesLength -= 1
+                    if (!databasesLength) {
+                        resolve(createData(data, collectionArray, type))
+                    }
 
+                } else {
+                    let collections
+                    if (action == 'updateCollection')
+                        collections = Object.entries(data[type])
+                    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))
+                                    }
+    
+                                }
+                            }, (err) => {
+                                errorHandler(data, err, database)
+                            }) 
+                            
+                        } else {
+                            collectionArray.push({name: collection, db: 'indexeddb', database})
+                            collectionsLength -= 1
+
+                            if (!collectionsLength)
+                                databasesLength -= 1
+
+                            if (!databasesLength && !collectionsLength) {
+                                resolve(createData(data, collectionArray, type))
+                            }
+                        }
 
-const createCollection = (data) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
+                    }
+    
+                }
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            if (!db.objectStoreNames.contains(data.collection)) { 
-                let version = openRequest.result.version
-                db.close()
-                
-                let request = indexedDB.open(data.database, Number(version += 1));
-                request.onupgradeneeded = function() {
-                    db = request.result;
-                    db.createObjectStore(data.collection, {keyPath: '_id', autoIncrement: true});
-                };
-        
-                request.onsuccess = function() {
-                    resolve(request.result)
-                };
-            
-                request.onerror = function() {
-                    console.log("Error", request.error);
-                    reject(request.error)
-                };
+            };
         
-            } else {
-                resolve(db)
-            }
-        };
-
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
+            openRequest.onerror = function() {
+                errorHandler(data, openRequest.error, database)
+                databasesLength -= 1
 
+                if (!databasesLength) {
+                    resolve(data)
+                }
+            };
+        }
     }, (err) => {
-        console.log(err);
+        errorHandler(data, err)
     });
 }
 
-const readCollections = (data) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            let collections = db.objectStoreNames
-            data.data = [];
-            
-            for (let collection of Array.from(collections)){
-                data.data.push({name: collection})
-            }
+function createIndex(data){
+    return index('createIndex', data)
+}
 
-            data.collection = 'collections'
-            resolve(data)
-        }
+function readIndex(data) {
+    return index('readIndex', data)
+}
 
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
+function updateIndex(data) {
+    return index('updateIndex', data)
+}
 
-    }, (err) => {
-        console.log(err);
-    });
+function deleteIndex(data) {
+    return index('deleteIndex', data)
 }
 
-const updateCollection = (data) => {
+const index = (action, data) => {
     return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.dastabase);
+        let type = 'index'
+        let indexArray = [];
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            if (db.objectStoreNames.contains(data.collection)) { 
-                let version = openRequest.result.version
-                db.close()
-                
-                let request = indexedDB.open(data.dastabase, Number(version += 1));
-                request.onupgradeneeded = function() {
-                    let db = request.result;
-                    let transaction = db.transaction([data.collection], "readonly");
-                    let collection = transaction.objectStore(data.collection);
-                    collection.name = data.newCollection
-                }
-
-                request.onsuccess = function() {
-                    db.close()
-                    resolve(request.result)
-                };
-            
-                request.onerror = function() {
-                    reject(request.error)
-                };
-                
-            } else {
-                db.createObjectStore(data.newCollection, {keyPath: '_id', autoIncrement: true})
-                resolve(data.newCollection)
-            }
-        };
+        if (data.request)
+            data[type] = data.request
 
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
-
-    }, (err) => {
-        console.log(err);
-    });
-}
+        if (!data['timeStamp'])
+            data['timeStamp'] = new Date().toISOString()
+        
+        let databases = data.database;  
+        if (!Array.isArray(databases))
+            databases = [databases]
+
+        let databasesLength = databases.length
+        for (let database of databases) {
+            let collections = data.collection;
+            if (!Array.isArray(collections))
+                collections = [collections]
+
+            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 Array.from(indexNames)) {
+                                indexArray.push({name: index, db: 'indexeddb', database, collection})
+                            }
+                            collectionsLength -= 1
+                            db.close()
 
-const deleteCollection = (data) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
+                            if (!collectionsLength)
+                                databasesLength -= 1
+    
+                            if (!databasesLength && !collectionsLength)
+                                resolve(createData(data, indexArray, type))
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            if (db.objectStoreNames.contains(data.collection)) { 
-                let version = openRequest.result.version
-                db.close()
-                
-                let request = indexedDB.open(data.database, Number(version += 1));
-                request.onupgradeneeded = function() {
-                    db = request.result;
-                    db.deleteObjectStore(data.collection)
-                }
+                        } else {
+                            db.close()
+                            let indexes
+                            if (action == 'updateIndex')
+                                indexes = Object.entries(data[type])
+                            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()
+
+                                    indexesLength -= 1
+
+                                    if (!indexesLength)
+                                        collectionsLength -= 1
+                                        
+                                    if (!collectionsLength)
+                                        databasesLength -= 1                                    
+                                    
+                                    if (!databasesLength && !collectionsLength && !indexesLength) {
+                                        resolve(createData(data, indexArray, type))
+                                    }                                
+                                });
+                            }
+        
+                        } 
+        
+                    } else {
+                        db.close()
+                        errorHandler(data, `collection: ${collection} does not exist`, database, collection)
+                        resolve(data)
+                    }
+                });                                        
 
-                request.onsuccess = function() {
-                    // let db = request.result;
-                    db.close()
-                    resolve(data.collection)
-                };
-            
-                request.onerror = function() {
-                    reject(request.error)
-                };
-                
-            };
-        };
-    
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
+            }    
+        }
 
     }, (err) => {
-        console.log(err);
+        errorHandler(data, err)
     });
 }
 
-const createIndex = (data) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
-
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            let transaction = db.transaction([data.collection], "readonly");
-            let collection = transaction.objectStore(data.collection);
-            
-            if (!collection.indexNames.contains(data.name)){
-                let version = openRequest.result.version
-                db.close()
-                
-                let request = indexedDB.open(data.database, Number(version += 1));
-                request.onupgradeneeded = function() {
-                    db = request.result;
-                    transaction = db.transaction([data.collection], "readonly");
-                    collection = transaction.objectStore(data.collection);
-                    collection.createIndex(data.name, data.name, {unique: false})
-                }
-
-                request.onsuccess = function() {
-                    db.close()
-                    resolve('index created')
-                };
-
-                request.onerror = function() {
-                    reject(request.error)
-                };
-    
-            } else {
-                resolve('index created')
-            }
-        };
-            
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
-    })
-
+function createDocument(data){
+    return document('createDocument', data)
+}
 
+function readDocument(data) {
+    return document('readDocument', data)
 }
-const readIndex = (data) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            let transaction = db.transaction([data.collection], "readonly");
-            let collection = transaction.objectStore(data.collection); 
-            let indexes = collection.indexNames
-            db.close()
-            resolve(indexes)
-        };
-            
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
-    })
+function updateDocument(data) {
+    return document('updateDocument', data)
+}
 
+function deleteDocument(data) {
+    return document('deleteDocument', data)
 }
 
-const updateIndex = (data) => {
+
+const document = (action, data) => {
     return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
+        let type = 'document'
+        let documents = []
+        
+        if (data.request)
+            data[type] = data.request
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            let transaction = db.transaction([data.collection], "readonly");
-            let collection = transaction.objectStore(data.collection);
-            
-            if (collection.indexNames.contains(data.oldName)){
-                let version = openRequest.result.version
-                db.close()
-                
-                let request = indexedDB.open(data.database, Number(version += 1));
-                request.onupgradeneeded = function() {
-                    db = request.result;
-                    transaction = db.transaction([data.collection], "readonly");
-                    collection = transaction.objectStore(data.collection);
-                    let index = store.index(data.oldName);
-                    index.name = data.newName;
-                }
+        if (!data['timeStamp'])
+            data['timeStamp'] = new Date().toISOString()
+        
+        let databases = data.database;  
+        if (!Array.isArray(databases))
+            databases = [databases]
+
+        let databasesLength = databases.length
+        for (let database of databases) {
+            getDatabase({database}).then((db) => {
+                let collections = data.collection;
+                if (!Array.isArray(collections))
+                    collections = [collections]
+
+                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') {
+                                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))
+                                    }
+                                })
+                            }
 
-                request.onsuccess = function() {
-                    let db = request.result;
-                    db.close()
-                    resolve('index does not exist')
-                };
+                        }).catch((error) => {
+                            errorHandler(data, {message: error, data}, database)
+                            collectionsLength -= 1
+                                            
+                            if (!collectionsLength)
+                                databasesLength -= 1
 
-                request.onerror = function() {
-                    reject(request.error)
-                };
+                            if (!databasesLength && !collectionsLength) 
+                                resolve(createData(data, documents, type))
+        
+                        })
+
+                    } else { 
+                        if (data.filter || action == 'readDocument' && !data.document) {
+                            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);
     
-            } else {
-                collection.createIndex(data.newName, data.newName, {unique: false})
-                db.close()
-                resolve('index does not exist')
-            }
-        };
-            
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
-    })
+                            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))
+                                }
+                            })
+                        }
+                    }
+                }
 
-}
-const deleteIndex = (data) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
+            }).catch((error) => {
+                errorHandler(data, {message: error, data}, database)
 
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            let transaction = db.transaction([data.collection], "readonly");
-            let collection = transaction.objectStore(data.collection);
-            
-            if (collection.indexNames.contains(data.name)){
-                let version = openRequest.result.version
-                db.close()
-                
-                let request = indexedDB.open(data.database, Number(version += 1));
-                request.onupgradeneeded = function() {
-                    db = request.result;
-                    transaction = db.transaction([data.collection], "readonly");
-                    collection = transaction.objectStore(data.collection);
-                    collection.deleteIndex(data.name)
-                }
+                databasesLength -= 1
 
-                request.onsuccess = function() {
-                    let db = request.result;
-                    db.close()
-                    resolve('index does not exist')
-                };
+                if (!databasesLength) 
+                    resolve(createData(data, documents, type))
+            })
 
-                request.onerror = function() {
-                    reject(request.error)
-                };
-    
-            } else {
-                db.close()
-                resolve('index does not exist')
-            }
-        };
-            
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
+        }
     })
-
 }
 
-const createDocument = (data) => {
+function runDocs({action, data, objectStore, documents, filterDocs, database, collection, type}) {
     return new Promise((resolve, reject) => {
-        database(data).then((db) => {
-            let transaction = db.transaction([data.collection], "readwrite");
-            let collection = transaction.objectStore(data.collection);
-            if (!data.data._id)
-                data.data['_id'] = ObjectId()
-            let request = collection.add(data.data);
-            
-            request.onsuccess = function() {
-                db.close()
-                resolve(data)
-            };
-            
-            request.onerror = function() {
-                db.close()
-                reject(request.error)
-            };
+        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]})
+        
 
-        }, (err) => {
-            console.log(err);
-        })
-    })
-}
+        if (filterDocs && filterDocs.length) {
+            if (action == 'readDocument') {
+                for (let i = 0; i < filterDocs.length; i++)
+                    documents.push({db: 'indexeddb', database, collection, ...filterDocs[i]})
 
-const readDocument = (data, db, collection) => {
-    return new Promise((resolve, reject) => {
-        if (db && collection) {
-            let request = collection.get(data.data._id);
-                
-            request.onsuccess = function() {
-                data.data = request.result
-                resolve(data)
-            };
-            
-            request.onerror = function() {
-                reject(request.error)
-            };
-        } else {
+            }
 
-                let openRequest = indexedDB.open(data.database);
+            if (action == 'updateDocument') {
+                let updateData = docs[0];
+                if (updateData)
+                    docs.shift();
+                for (let filterDoc of filterDocs) {
+                    filterDoc = dotNotationToObject(filterDoc, updateData)
+                    docs.push(filterDoc)
+                }
+            }
 
-                openRequest.onsuccess = function() {
-                    try {
+            if (action == 'deleteDocument')
+                docs.push(...filterDocs)
+        }
 
-                        let db = openRequest.result;
-                        let transaction = db.transaction([data.collection], "readwrite");
-                        let collection = transaction.objectStore(data.collection);
-                        let request = collection.get(data.data._id);
-                        
-                        request.onsuccess = function() {
-                            db.close()
-                            data.data = request.result
-                            resolve(data)
-                        };
-                        
-                        request.onerror = function() {
-                            db.close()
-                            reject(request.error)
-                        };
-                    } catch (err) {
-                        data.data = {}
-                        // data.error = err
-                        resolve(data)
-                        return 
+        let docsLength = docs.length
+       
+        if (docsLength > 0) {
+            for (let doc of docs) {
+                // ToDo deDuplcate document_id per collection
+                if (action == 'updateDocument' || action == 'deleteDocument') {
+                    if (doc._id) {
+                        doc['organization_id'] = data.organization_id
+                        doc['modified'] = {on: data.timeStamp, by: data.user || data.clientId}
+
+                        updateDoc(action, data, doc, objectStore, database, collection).then((doc) => {
+                            doc.db = '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)
+
+                        doc['organization_id'] = data.organization_id
+                        doc['created'] = {on: data.timeStamp, by: data.user || data.clientId}
+                        request = objectStore.add(doc);
                     }
-                };
 
-                openRequest.onerror = function() {
-                    reject(openRequest.error)
-                };
+                    if (action == 'readDocument') {
+                        request = objectStore.get(doc._id);
+                    }
+                    
+                    request.onsuccess = function() {
+                        if (request.result) {
+                            if (action == 'readDocument')
+                                doc = request.result
+                            doc.db = '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 {
+            resolve()
         }
+    }, (err) => {
+        errorHandler(data, {message: err, document: doc}, database, objectStore.name)
     })
 }
 
-const updateDocument = (data) => {
+function updateDoc(action, data, doc, objectStore, database, collection) {
     return new Promise((resolve, reject) => {
-        database(data).then((db) => {
-            let transaction = db.transaction([data.collection], "readwrite");
-            let collection = transaction.objectStore(data.collection);
-           
-            if (!data.data._id && data.upsert == true) {
-                data.data['_id'] = ObjectId() 
-            }
-            if (!data.data._id) {
-                db.close()
-                resolve(data['error'] = 'requires _id')
-            } else {
-                let get = collection.get(data.data._id)
-                get.onsuccess = function() {;
-                    // ToDo: merge objects and update using dot notation
-                    if (get.result || data.upsert == true) {
-                        data.data = dotNotationToObject(data.data, get.result)
-
-                        if (data.updateName){
-                            for (let [key, value] of Object.entries(data.updateName)){
-                                let val = data.data[key]
-                                delete data.data[key]
-                                data.data[value] = val
-                            }
-
-                        }  
-
-                        if (data.deleteName){
-                            for (let key of Object.keys(data.deleteName)){
-                                delete data.data[key]
+            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 (action == 'updateDocument') {
+                            doc = dotNotationToObject(doc, get.result)
+
+                            if (data.updateName){
+                                for (let [key, value] of Object.entries(data.updateName)){
+                                    let val = doc[key]
+                                    delete doc[key]
+                                    doc[value] = val
+                                }
+                            }  
+        
+                            if (data.deleteName){
+                                for (let key of Object.keys(data.deleteName)){
+                                    delete doc[key]
+                                }
+        
                             }
+        
+                            let put = objectStore.put(doc);
+                            
+                            put.onsuccess = function() {
+                                resolve(doc)
+                            };
+                            
+                            put.onerror = function() {
+                                errorHandler(data, put.error, database, collection, doc)
+                                resolve(doc)
+                            };
+    
+                        }
 
+                        if (action == 'deleteDocument') {
+                            let deleteDoc = objectStore.delete(doc._id);
+                            
+                            deleteDoc.onsuccess = function() {
+                                resolve(doc)
+                            };
+                            
+                            deleteDoc.onerror = function() {
+                                errorHandler(data, deleteDoc.error, database, collection, doc)
+                                resolve(doc)
+                            };
                         }
     
-                        let put = collection.put(data.data);
-                        
-                        put.onsuccess = function() {
-                            db.close()
-                            resolve(data)
-                        };
-                        
-                        put.onerror = function() {
-                            db.close()
-                            reject(put.error)
-                        };
                     } else {
-                        db.close()
-                        reject('document doest not exist and upsert is not true')
+                        // ToDo: handle if _id not found upsert
+                        errorHandler(data, 'doc in db is newer', database, collection, doc)
+                        resolve(doc)
                     }
-                };
-                
-                get.onerror = function() {
-                    db.close()
-                    reject(get.error)
-                };
-            }
-        })
-    })
-}
+                } else {
+                    errorHandler(data, 'document doest not exist and upsert is not true', database, collection, doc)
+                    resolve(doc)
+                }
 
-const deleteDocument = (data) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
-        
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            let transaction = db.transaction([data.collection], "readwrite");
-            let collection = transaction.objectStore(data.collection);
-                        
-            let request = collection.delete(data.data._id);
-            
-            request.onsuccess = function() {
-                db.close()
-                resolve(data)
             };
             
-            request.onerror = function() {
-                db.close()
-                reject(request.error)
+            get.onerror = function() {
+                errorHandler(data, get.error, database, collection, doc)
+                resolve(doc)
             };
-        } 
-        openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
+        
     })
 }
 
-const readDocuments = (data) => {
+const readDocuments = (data, database, collection) => {
     return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
+        let openRequest = indexedDB.open(database);
         
         openRequest.onsuccess = function() {
             let db = openRequest.result;
             try {
-                // var transaction = db.transaction([data.collection], "readonly");
-                let transaction = db.transaction([data.collection], "readonly");
-                let collection = transaction.objectStore(data.collection);
+                let transaction = db.transaction([collection], "readonly");
+                let objectStore = transaction.objectStore(collection);
                 let results = [];
-                // let index = collection.index(filter.name);
+                // let index = objectStore.index(filter.name);
                 // let request = index.openCursor(IDBKeyRange.upperBound(filter.value));
-                let request = collection.openCursor();
+                let request = objectStore.openCursor();
                 // transaction.oncomplete = resolve(results);
 
                 request.onsuccess = function() {
                     let isFilter;
+                    // if (data['organization_id']) {
+					// 	data['filter']['query']['organization_id'] = data['organization_id'];
+					// }
+
                     let cursor = request.result;
                     if (cursor) {
                         let value = cursor.value;
@@ -642,69 +878,31 @@ const readDocuments = (data) => {
                             results.push(value)
                         cursor.continue();
                     } else {
-                        data.data = results
+                        let docs = results
                         if (data.filter) {
                             if (data.filter.search)
-                                data.data = searchData(data.data, data.filter)
-                            if (data.filter.sort)
-                                data.data = sortData(data.data, data.filter.sort)
+                            docs = searchData(docs, data.filter)
                         }
-                        resolve(data)
+
+                        resolve(docs)
                     }
                 };
                 
                 request.onerror = function() {
-                    request.data = []
-                    reject(request.error)
+                    errorHandler(data, request.error, database, collection)
+                    resolve([])
                 };
             } catch (err) {
-                data.data = []
-                // data.error = err
-                resolve(data)
+                errorHandler(data, err, database)
+                resolve([])
                 return 
             }
 
         };
 
         openRequest.onerror = function() {
-            reject(openRequest.error)
-        };
-    })
-}
-
-const sync = (action, data) => {
-    return new Promise((resolve, reject) => {
-        let openRequest = indexedDB.open(data.database);
-        
-        openRequest.onsuccess = function() {
-            let db = openRequest.result;
-            let transaction = db.transaction([data.collection], "readonly");
-            let collection = transaction.objectStore(data.collection);
-            
-            if (Array.isArray(data.data)) {
-                for (let item of data.data) {
-                    readDocument(item, db, collection).then((doc) => {
-                        if (doc.modified.on < item.modifed.on) {
-                            collection.put(item)
-                        }
-
-                    })
-                }
-            } else {
-                readDocument(item, db, collection).then((doc) => {
-                    if (doc.modified.on < item.modifed.on) {
-                        collection.put(item)
-                    }
-
-                })
-            }
-
-            db.close()
-            resolve('synced')
-        };
-
-        openRequest.onerror = function() {
-            reject(openRequest.error)
+            errorHandler(data, openRequest.error)
+            resolve(data)
         };
     })
 }
@@ -721,7 +919,7 @@ async function generateDB(data) {
 		let organization = {
             database: organization_id,
 			collection: 'organizatons',
-			data: {
+			document: {
 				_id: organization_id,
 				name: 'untitled',
 				organization_id,
@@ -735,7 +933,7 @@ async function generateDB(data) {
 			let permissions = {	
                 database: organization_id,
 				collection: 'permissions',
-				data: {
+				document: {
 					_id: ObjectId(),
 					organization_id,
 					type: "apikey",
@@ -778,7 +976,7 @@ async function generateDB(data) {
 			let user = {
                 database: organization_id,
 				collection: 'users',
-				data: {
+				document: {
 					_id: user_id,
 					password: btoa('0000'),
 					connected_orgs: [organization_id],
@@ -794,7 +992,7 @@ async function generateDB(data) {
 			let role = {
                 database: organization_id,
 				collection: 'permissions',
-				data: {
+				document: {
 					_id: ObjectId(),
 					organization_id,
 					"type": "role",
@@ -818,7 +1016,7 @@ async function generateDB(data) {
 				let data = {
                     database: organization_id,
 					collection: 'permissions',
-					data: {
+					document: {
 						_id: ObjectId(),
 						organization_id,
 						"type": "user_id",
@@ -832,10 +1030,45 @@ async function generateDB(data) {
         return true			
 		
 	} catch (error) {
-		console.log(error)
+        errorHandler(data, error)
 	}
 }
 
+function errorHandler(data, error, database, collection){
+    if (typeof error == 'object')
+        error['db'] = 'indexeddb'
+    else
+        error = {db: 'indexeddb', message: error}
+
+    if (database)
+        error['database'] = database
+    if (collection)
+        error['collection'] = collection
+    if(data.error)
+        data.error.push(error)
+    else
+        data.error = [error]
+
+}
+
+function createData(data, array, type) {
+    data.request = data[type] || {}
+
+    if (data.filter && data.filter.sort)
+        data[type] = sortData(array, data.filter.sort)
+    else
+        data[type] = array
+    
+    if (data.returnLog){
+        if (!data.log)
+            data.log = []
+        data.log.push(...data[type])
+    }
+
+    return data
+}
+
+
 const ObjectId = (rnd = r16 => Math.floor(r16).toString(16)) =>
     rnd(Date.now()/1000) + ' '.repeat(16).replace(/./g, () => rnd(Math.random()*16));
 
@@ -850,15 +1083,14 @@ function init() {
 init();
 
 export default {
-    database,
+    getDatabase,
     createDatabase,
     readDatabase,
-    readDatabases,
     updateDatabase,
     deleteDatabase,
     
     createCollection,
-    readCollections,
+    readCollection,
     updateCollection,
     deleteCollection, 
 
@@ -869,11 +1101,9 @@ export default {
 
     createDocument, 
     readDocument,
-    readDocuments,
     updateDocument, 
     deleteDocument, 
 
-    sync,
     ObjectId,
     generateDB
 };