@cocreate/indexeddb 1.16.1 → 1.17.0

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+# [1.17.0](https://github.com/CoCreate-app/CoCreate-indexeddb/compare/v1.16.2...v1.17.0) (2023-11-03)
+
+
+### Bug Fixes
+
+* favicon.ico path ([3ea941e](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/3ea941e1e70879aa171ec3b98a81dc3769ec80f2))
+* get.database updated to database.get ([b8058c6](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/b8058c6bbe5682d9bc7f29775b3f306babcd5108))
+* relocated $filter conditions to after index is open ([349f7ff](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/349f7ff33b08ba0da77a313135523b6ccf3a9b41))
+* transaction bug ([6016c07](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/6016c07c56b8dda63281783e810f4747d6e59d80))
+* update dependencies to the lates versions ([4bcf0b2](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/4bcf0b223a73d8e73aea2083abf37c066f8c1d3d))
+* update method to use object.update etc ([6b47872](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/6b47872704e19f7ba9cab7b544dfbad77aeed377))
+
+
+### Features
+
+* morph data[type] so the object can be synced across multiple storage, database, array ([8d3afb4](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/8d3afb487ab4d4709c8bcc2ded6bf8d2ffaa0085))
+
+## [1.16.2](https://github.com/CoCreate-app/CoCreate-indexeddb/compare/v1.16.1...v1.16.2) (2023-10-26)
+
+
+### Bug Fixes
+
+* expanded the  try catch ([ab77e43](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/ab77e434f4811832089d63256afb8e678209b4f7))
+
 ## [1.16.1](https://github.com/CoCreate-app/CoCreate-indexeddb/compare/v1.16.0...v1.16.1) (2023-10-25)
 
 

package/demo/index.html

@@ -6,9 +6,9 @@
         <meta name="viewport" content="width=device-width, initial-scale=1" />
         <link
             rel="icon"
-            href="https://cdn.cocreate.app/favicon.ico"
-            type="image/ico"
-            sizes="16x16" />
+            type="image/png"
+            sizes="32x32"
+            href="../assets/favicon.ico" />
         <title>indexeddb | CoCreateJS</title>
         <link rel="manifest" href="/manifest.webmanifest" />
     </head>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/indexeddb",
-  "version": "1.16.1",
+  "version": "1.17.0",
   "description": "A simple indexeddb component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "indexeddb",
@@ -58,6 +58,6 @@
     "webpack-log": "^3.0.1"
   },
   "dependencies": {
-    "@cocreate/utils": "^1.26.1"
+    "@cocreate/utils": "^1.26.2"
   }
 }

package/src/index.js

@@ -63,18 +63,13 @@ async function send(data) {
     try {
         let newData = [];
 
-        let type = data.method.split('.');
-        type = type[type.length - 1];
-
+        let type = data.method.split('.')[0];
         if (type === 'database') {
-            if (data.method === 'get.database') {
+            if (data.method === 'database.get') {
                 return await processDatabase(data)
             } else
                 await processDatabase(data, newData, type)
         } else {
-            if (data.request)
-                data[type] = data.request
-
             if (!data['timeStamp'])
                 data['timeStamp'] = new Date()
             else
@@ -105,7 +100,6 @@ async function send(data) {
             }
         }
 
-
         return createData(data, newData, type)
 
     } catch (error) {
@@ -118,13 +112,10 @@ const processDatabase = (data, newData, type) => {
     return new Promise((resolve, reject) => {
         if (!data)
             data = {}
-        if (data.request)
-            data[type] = data.request
-
-        // if (!data['timeStamp'])
-        data['timeStamp'] = new Date(data['timeStamp'])
+        if (!data[type])
+            data[type] = []
 
-        if (data.method == 'read.database') {
+        if (data.method == 'database.read') {
             indexedDB.databases().then((databases) => {
                 for (let database of databases) {
                     if (data.$filter && data.$filter.query) {
@@ -139,7 +130,7 @@ const processDatabase = (data, newData, type) => {
             })
         } else {
             let databases
-            if (data.method == 'update.database')
+            if (data.method == 'database.update')
                 databases = Object.keys(data.database)
             else
                 databases = data.database;
@@ -150,12 +141,12 @@ const processDatabase = (data, newData, type) => {
             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':
+                    case 'database.get':
+                    case 'database.create':
+                    case 'database.update':
                         openRequest = indexedDB.open(database);
                         break;
-                    case 'delete.database':
+                    case 'database.delete':
                         openRequest = indexedDB.deleteprocessDatabase(database);
                         break;
                     default:
@@ -166,7 +157,7 @@ const processDatabase = (data, newData, type) => {
                 openRequest.onsuccess = function () {
                     let db = openRequest.result;
 
-                    if (data.method == 'update.database') {
+                    if (data.method == 'database.update') {
                         let objectStoreNames = Array.from(db.objectStoreNames)
                         for (let array of objectStoreNames) {
                             let request = array.openCursor();
@@ -233,7 +224,7 @@ const processDatabase = (data, newData, type) => {
 
                         request.onsuccess = function (event) {
                             if (databases.length - 1 === i) {
-                                if (data.method == 'get.database')
+                                if (data.method == 'database.get')
                                     resolve(event.target.result)
                                 else
                                     resolve(data)
@@ -243,7 +234,7 @@ const processDatabase = (data, newData, type) => {
                         request.onerror = function (event) {
                             errorHandler(data, event.target.error, database, array)
                             if (databases.length - 1 === i) {
-                                if (data.method == 'get.database')
+                                if (data.method == 'database.get')
                                     resolve(event.target.result)
                                 else
                                     resolve(data)
@@ -251,7 +242,7 @@ const processDatabase = (data, newData, type) => {
                         };
 
                     } else if (databases.length - 1 === i) {
-                        if (data.method == 'get.database')
+                        if (data.method == 'database.get')
                             resolve(db)
                         else
                             resolve(data)
@@ -272,10 +263,10 @@ const processDatabase = (data, newData, type) => {
 }
 
 async function processArray(data, newData, database, type) {
-    let db = await processDatabase({ method: 'get.database', database })
+    let db = await processDatabase({ method: 'database.get', database })
 
     let objectStoreNames = Array.from(db.objectStoreNames)
-    if (data.method == 'read.array') {
+    if (data.method == 'array.read') {
         if (!data[type])
             data[type] = []
 
@@ -290,12 +281,12 @@ async function processArray(data, newData, database, type) {
     } else {
         db.close()
 
-        let request = await processDatabase({ method: 'get.database', database, upgrade: true })
+        let request = await processDatabase({ method: 'database.get', database, upgrade: true })
         await new Promise((resolve) => {
             request.onupgradeneeded = function (event) {
                 let db = event.target.result
                 let arrays
-                if (data.method == 'update.array')
+                if (data.method == 'array.update')
                     arrays = Object.keys(data[type])
                 else
                     arrays = data[type];
@@ -306,20 +297,20 @@ async function processArray(data, newData, database, type) {
                     let error, array = arrays[i]
 
                     let arrayExist = db.objectStoreNames.contains(array)
-                    if (arrayExist && data.method == 'create.array') {
+                    if (arrayExist && data.method == 'array.create') {
                         error = 'array already exists'
-                    } else if (data.method == 'delete.array') {
+                    } else if (data.method == 'array.delete') {
                         if (objectStoreNames.includes(array)) {
                             db.deleteObjectStore(array);
                         } else {
                             error = 'the array does not exist'
                         }
                     } else {
-                        if (!arrayExist && data.method == 'update.array')
+                        if (!arrayExist && data.method == 'array.update')
                             array = data[type][arrays[i]]
 
                         if (arrayExist) {
-                            if (data.method == 'update.array') {
+                            if (data.method == 'array.update') {
                                 let transaction = event.target.transaction;
                                 let objectStore = transaction.objectStore(array);
 
@@ -328,7 +319,7 @@ async function processArray(data, newData, database, type) {
                                 else
                                     error = 'An array with the new name already exist'
                             }
-                        } else if (data.method == 'update.array')
+                        } else if (data.method == 'array.update')
                             error = 'array does not exists'
                     }
 
@@ -356,7 +347,7 @@ async function processArray(data, newData, database, type) {
 }
 
 async function processIndex(data, newData, database, array, type) {
-    let db = await processDatabase({ method: 'get.database', database })
+    let db = await processDatabase({ method: 'database.get', database })
     let arrayExist = db.objectStoreNames.contains(array)
     if (arrayExist) {
         // ToDO: switch here to types
@@ -364,7 +355,7 @@ async function processIndex(data, newData, database, array, type) {
         let objectStore = transaction.objectStore(array);
         let indexNames = Array.from(objectStore.indexNames)
 
-        if (data.method == 'read.index') {
+        if (data.method == 'index.read') {
             for (let i = 0; i < indexNames.length; i++) {
                 let name = indexNames[i]
                 if (data.$filter && data.$filter.query)
@@ -376,7 +367,7 @@ async function processIndex(data, newData, database, array, type) {
         } else {
             db.close()
             let indexes
-            if (data.method == 'update.index')
+            if (data.method == 'index.update')
                 indexes = Object.keys(data[type])
             else
                 indexes = data[type];
@@ -386,20 +377,20 @@ async function processIndex(data, newData, database, array, type) {
 
             for (let i = 0; i < indexes.length; i++) {
                 let error, index = indexes[i]
-                db = await processDatabase({ method: 'get.database', database, upgrade: true })
+                db = await processDatabase({ method: 'database.get', database, upgrade: true })
                 let transaction = db.transaction;
                 let objectStore = transaction.objectStore(array);
                 let indexExist = indexNames.includes(index)
 
-                if (data.method == 'create.index') {
+                if (data.method == 'index.create') {
                     if (!indexExist)
                         objectStore.createIndex(index, index, { unique: false })
                     else
                         error = 'index already exist'
                 } else if (indexExist) {
-                    if (data.method == 'delete.index')
+                    if (data.method == 'index.delete')
                         objectStore.deleteIndex(index)
-                    else if (data.method == 'update.index' && !indexNames.includes(data[type][indexes[i]])) {
+                    else if (data.method == 'index.update' && !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]];
@@ -421,79 +412,76 @@ async function processIndex(data, newData, database, array, type) {
 }
 
 async function processObject(data, newData, database, array, type) {
-    let db = await processDatabase({ method: 'get.database', database })
+    let db = await processDatabase({ method: 'database.get', database })
 
-    let isFilter
-    if (data.$filter && data.$filter.query)
-        isFilter = true
+    try {
+        let isFilter
+        if (data.$filter && data.$filter.query)
+            isFilter = true
 
-    let arrayExist = db.objectStoreNames.contains(array)
-    if (!arrayExist) {
-        if (data.method == 'create.object' || data.method == 'update.object') {
+        let arrayExist = db.objectStoreNames.contains(array)
+        if (!arrayExist) {
             db.close()
-            db = await processDatabase({ method: 'get.database', database, array })
-        } else {
-            return errorHandler(data, "array does not exist", database, array)
+            if (data.method == 'object.create' || data.method == 'object.update') {
+                db = await processDatabase({ method: 'database.get', database, array })
+            } else {
+                return errorHandler(data, "array does not exist", database, array)
+            }
         }
-    }
-
-    if (!array || !db)
-        throw new Error({ error: "This is an error message.", db, array });
 
-    let transactionType = "readwrite" //test
-    if (data.method == 'read.object')
-        transactionType = "readonly"
+        if (!array || !db)
+            throw new Error({ error: "This is an error message.", db, array });
 
-    let transaction = db.transaction([array], transactionType);
-    let objectStore = transaction.objectStore(array);
-    if (!data[type])
-        data[type] = []
-    if (data[type] && !Array.isArray(data[type]))
-        data[type] = [data[type]]
+        if (!data[type])
+            data[type] = []
+        if (data[type] && !Array.isArray(data[type]))
+            data[type] = [data[type]]
 
-    if (isFilter && !data[type].length)
-        data[type] = [{}]
+        if ((isFilter && !data[type].length) || data.isFilter)
+            data[type] = [{ isFilter: 'isEmptyObjectFilter' }];
+        // data[type].splice(0, 0, { isFilter: 'isEmptyObjectFilter' });
 
-    let globalOperators = getGlobalOperators(data)
-    let upsert = data.upsert
+        let transactionType = "readwrite"
+        if (data.method == 'object.read')
+            transactionType = "readonly"
 
-    if (data.$filter) {
-        let count = objectStore.count();
-        count.onsuccess = function () {
-            data.$filter.count = count.result
-        }
-    }
+        let transaction = db.transaction([array], transactionType);
+        let objectStore = transaction.objectStore(array);
 
-    try {
+        let globalOperators = getGlobalOperators(data)
+        let upsert = data.upsert
 
         for (let i = 0; i < data[type].length; i++) {
             delete data[type][i].$storage
             delete data[type][i].$database
             delete data[type][i].$array
 
-            if (data.method == 'create.object') {
+            if (data.method == 'object.create') {
                 if (data.organization_id)
                     data[type][i]['organization_id'] = data.organization_id
 
                 if (!data[type][i]._id)
                     data[type][i]['_id'] = ObjectId().toString()
                 data[type][i] = dotNotationToObject(data[type][i])
+
+                // TODO: user_id || clientId shohould be retrieved from CoCreate
                 data[type][i]['created'] = { on: data.timeStamp, by: data.user_id || data.clientId }
+                data[type][i] = await add(objectStore, data[type][i])
+                data[type][i].$storage = 'indexeddb'
+                data[type][i].$database = database
+                data[type][i].$array = array
 
-                let result = await add(objectStore, data[type][i])
-                newData.push({ $storage: 'indexeddb', $database: database, $array: array, ...result })
             } else {
                 if (data[type][i].$filter)
                     isFilter = true
-                // if (data.organization_id)
-                //     data[type][i]['organization_id'] = data.organization_id
 
-                if (data.method == 'update.object') {
+                if (data.method == 'object.update') {
                     if (data.organization_id)
                         data[type][i]['organization_id'] = data.organization_id
 
                     if (data[type][i].$upsert)
                         upsert = data[type][i].$upsert
+                    // TODO: user_id || clientId shohould be retrieved from CoCreate
                     data[type][i]['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
                 }
 
@@ -501,13 +489,6 @@ async function processObject(data, newData, database, array, type) {
                 if (data[type][i]._id)
                     range = IDBKeyRange.only(data[type][i]._id);
                 else if (isFilter) {
-                    if (data.object.$filter) {
-                        let count = objectStore.count();
-                        count.onsuccess = function () {
-                            data.object.$filter.count = count.result
-                        }
-                    }
-
                     let isIndex = false
                     let indexName, direction;
 
@@ -546,22 +527,39 @@ async function processObject(data, newData, database, array, type) {
                         let indexExist = indexNames.includes(indexName)
                         if (!indexExist) {
                             db.close()
-                            db = await processDatabase({ method: 'get.database', database, array, indexName, upgrade: true })
-                            objectStore = db.transaction(array, 'readwrite');
+                            db = await processDatabase({ method: 'database.get', database, array, indexName })
+                            transaction = db.transaction(array, 'readwrite');
                             objectStore = transaction.objectStore(array);
                         }
                         objectStore = objectStore.index(indexName);
                     }
 
+                    let count = objectStore.count();
+                    count.onsuccess = function () {
+                        if (data.$filter)
+                            data.$filter.count = count.result
+                        else if (data.object.$filter)
+                            data.object.$filter.count = count.result
+                    }
+
                     if (data.$filter) {
                         if (data.$filter.index)
                             index = data.$filter.index
                         if (data.$filter.limit)
                             limit = data.$filter.limit
-                        if (limit)
-                            limit = (index || 0) + limit;
                     }
-                } else if (data.method == 'delete.object' || data.method == 'update.object' && !range && !upsert && !isFilter) {
+
+                    if (data[type][i].$filter) {
+                        if (data[type][i].$filter.index)
+                            index = data[type][i].$filter.index
+                        if (data[type][i].$filter.limit)
+                            limit = data[type][i].$filter.limit
+                    }
+
+                    if (limit)
+                        limit = (index || 0) + limit;
+
+                } else if (data.method == 'object.delete' || data.method == 'object.update' && !range && !upsert && !isFilter) {
                     continue
                 }
 
@@ -572,29 +570,34 @@ async function processObject(data, newData, database, array, type) {
             }
 
         }
+
+        if (db.close)
+            db.close()
+
     } catch (error) {
         errorHandler(data, error, database, array)
-    }
+        if (db.close)
+            db.close()
 
-    db.close()
+    }
 }
 
 function openCursor(objectStore, range, direction, data, newData, isFilter, limit, database, array, upsert, type, i, globalOperators) {
     return new Promise(async (resolve, reject) => {
         const request = objectStore.openCursor(range || null, direction);// next, prev
 
-        let hasUpdated
+        let hasUpdated, matchedLength = 0
         request.onsuccess = async () => {
             let cursor = request.result
 
-            if (data.method === 'create.object'
-                || data.method === 'update.object'
+            if (data.method === 'object.create'
+                || data.method === 'object.update'
                 && (!range && !isFilter && upsert || !cursor && upsert && !hasUpdated)) {
                 let isMatch = true
                 if (isFilter) {
                     if (cursor)
                         isMatch = filter(objectStore, data[type][i], data[type][i], cursor.value)
-                    else if (data.method === 'update.object' && !upsert)
+                    else if (data.method === 'object.update' && !upsert)
                         isMatch = false
                 }
 
@@ -606,20 +609,19 @@ function openCursor(objectStore, range, direction, data, newData, isFilter, limi
                     }
 
                     let result
-                    if (data.method == 'create.object') {
-                        result = await add(objectStore, data[type][i])
-                    } else if (data.method == 'update.object') {
-                        let update
-                        if (cursor)
-                            update = createUpdate(cursor.value, data[type][i], globalOperators)
-                        else
-                            update = createUpdate({}, data[type][i], globalOperators)
+                    if (data.method == 'object.create') {
+                        data[type][i] = await add(objectStore, data[type][i])
+                    } else if (data.method == 'object.update') {
+                        let update = createUpdate((cursor && cursor.value) ? cursor.value : {}, data[type][i], globalOperators)
                         if (update)
-                            result = await put(objectStore, update)
+                            data[type][i] = await put(objectStore, update)
                     }
+                    data[type][i].$storage = 'indexeddb'
+                    data[type][i].$database = database
+                    data[type][i].$array = array
+
+                    matchedLength++
 
-                    if (result)
-                        newData.push({ $storage: 'indexeddb', $database: database, $array: array, ...result })
                 }
                 resolve();
             } else if (cursor) {
@@ -630,7 +632,7 @@ function openCursor(objectStore, range, direction, data, newData, isFilter, limi
                 if (isMatch !== false) {
                     let result = cursor.value
 
-                    if (data.method == 'update.object') {
+                    if (data.method == 'object.update') {
                         let update = createUpdate(cursor.value, data[type][i], globalOperators)
                         if (update)
                             result = await put(objectStore, update)
@@ -639,15 +641,25 @@ function openCursor(objectStore, range, direction, data, newData, isFilter, limi
                         // TODO: if update.$<operator>.someKey[] requires the index of inerted item added to the field name. update.$<operator>.someKey[<index>] 
                         // TODO: if $addToSet get field name and item if it does not exist. 
                         // TODO: if $pull get field name and find if item exist and delete.
-                    } else if (data.method == 'delete.object') {
+                    } else if (data.method == 'object.delete') {
                         result = cursor.value
                         cursor.delete()
                     }
 
-                    newData.push({ $storage: 'indexeddb', $database: database, $array: array, ...result })
+                    if (data[type][i]._id)
+                        data[type][i] = { $storage: 'indexeddb', $database: database, $array: array, ...result }
+                    else {
+                        let object = data[type].find(obj => obj._id && obj._id === result._id)
+                        if (object)
+                            object = { $storage: 'indexeddb', $database: database, $array: array, ...object, ...result }
+                        else
+                            newData.push({ $storage: 'indexeddb', $database: database, $array: array, ...result })
+                    }
+
+                    matchedLength++
                 }
 
-                if (!limit || limit && limit < newData.length) {
+                if (!limit || limit && (limit < newData.length || limit < matchedLength)) {
                     cursor.continue();
                 } else if (cursor.close) {
                     cursor.close()
@@ -655,6 +667,7 @@ function openCursor(objectStore, range, direction, data, newData, isFilter, limi
                 } else {
                     resolve();
                 }
+
             } else {
                 resolve();
             }
@@ -707,15 +720,6 @@ function filter(objectStore, data, object, result) {
     let isMatch = true;
     let filter = data.$filter || object.$filter
     if (filter) {
-        try {
-            let count = objectStore.count();
-            count.onsuccess = function () {
-                filter.count = count.result
-            }
-        } catch (error) {
-            errorHandler(data, error, database, array)
-        }
-
         if (filter.query)
             isMatch = queryData(result, filter.query);
         if (isMatch && filter.search)
@@ -850,18 +854,17 @@ function dotNotationToObjectUpdate(data, object = {}) {
 }
 
 function createData(data, newData, type) {
-    data.request = data[type] || {}
+    // data.request = data[type] || {}
+    if (data[type] && data[type][0] && data[type][0].isFilter === 'isEmptyObjectFilter') {
+        data[type].shift()
+        data.isFilter = true
+    }
+
+    data[type].push(...newData)
 
     if (data.$filter && data.$filter.sort)
-        data[type] = sortData(newData, data.$filter.sort)
-    else
-        data[type] = newData
+        data[type] = sortData(data[type], data.$filter.sort)
 
-    if (data.returnLog) {
-        if (!data.log)
-            data.log = []
-        data.log.push(...data[type])
-    }
 
     return data
 }

package/test/collections.js

@@ -1,37 +1,37 @@
-async function testCollections() {
+async function testArrays() {
     if (!('indexedDB' in window)) {
         console.log("This browser doesn't support IndexedDB.");
         return;
     } else {
 
-        let createCollection = await CoCreate.indexeddb.process({
-            method: 'create.array',
-            database: ['testDB', 'testDB1', 'testDB2'],
-            array: ['testCollection', 'testCollection1', 'testCollection2']
+        let createObject = await CoCreate.indexeddb.process({
+            method: 'array.create',
+            database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
+            array: ['testArray', 'testArray1', 'testArray2']
 
         })
-        console.log('createCollection', createCollection)
+        console.log('createObject', createObject)
 
-        let readCollection = await CoCreate.indexeddb.process({
-            method: 'read.array',
-            database: ['testDB', 'testDB1', 'testDB2'],
+        let readObject = await CoCreate.indexeddb.process({
+            method: 'array.read',
+            database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
         })
-        console.log('readCollection', readCollection)
+        console.log('readObject', readObject)
 
-        let updateCollection = await CoCreate.indexeddb.process({
-            method: 'update.array',
-            database: ['testDB', 'testDB1', 'testDB2'],
-            array: { testCollection: 'testCollectionA' }
+        let updateObject = await CoCreate.indexeddb.process({
+            method: 'array.update',
+            database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
+            array: { testArray: 'testArrayA' }
         })
-        console.log('updateCollection', updateCollection)
+        console.log('updateObject', updateObject)
 
 
-        let deleteCollection = await CoCreate.indexeddb.process({
-            method: 'delete.array',
-            database: ['testDB', 'testDB1', 'testDB2'],
-            array: ['testCollectionA', 'testCollection1', 'testCollection2']
+        let deleteObject = await CoCreate.indexeddb.process({
+            method: 'array.delete',
+            database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
+            array: ['testArrayA', 'testArray1', 'testArray2']
         })
-        console.log('deleteCollection', deleteCollection)
+        console.log('deleteObject', deleteObject)
 
     }
 }

package/test/databases.js

@@ -4,26 +4,26 @@ async function testDatabases() {
         return;
     } else {
         let createDatabase = await CoCreate.indexeddb.process({
-            method: 'create.database',
+            method: 'database.create',
             database: 'testDB',
         })
         console.log('createDatabase', createDatabase)
 
         let readDatabase = await CoCreate.indexeddb.process({
-            method: 'read.database',
+            method: 'database.read',
             database: 'testDB',
         })
         console.log('readDatabase', readDatabase)
 
         let updateDatabase = await CoCreate.indexeddb.process({
-            method: 'update.database',
+            method: 'database.update',
             database: { testDB: 'testDatabase1' }
         })
         console.log('updateDatabase', updateDatabase)
 
 
         let deleteDatabase = await CoCreate.indexeddb.process({
-            method: 'delete.database',
+            method: 'database.delete',
             database: ['testDB', 'testDB1', 'testDB2'],
         })
         console.log('deleteDatabase', deleteDatabase)

package/test/documents.js

@@ -1,13 +1,13 @@
 async function testDocuments() {
-    if (!('indexedDB' in window)) {
-        console.log("This browser doesn't support IndexedDB.");
+    if (!('indexedDatabase' in window)) {
+        console.log("This browser doesn't support IndexedDatabase.");
         return;
     } else {
 
-        let createDocument = await CoCreate.indexeddb.process({
-            method: 'create.object',
-            database: ['testDB', 'testDB1', 'testDB2'],
-            array: ['testCollection', 'testCollection1', 'testCollection2'],
+        let createObject = await CoCreate.indexeddb.process({
+            method: 'object.create',
+            database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
+            array: ['testArray', 'testArray1', 'testArray2'],
             object: {
                 organization_id: '5ff747727005da1c272740ab',
                 'books.action.title': 'matr',
@@ -15,24 +15,24 @@ async function testDocuments() {
             }
 
         })
-        console.log('createDocument', createDocument)
-        let _id = createDocument.object[0]._id
+        console.log('createObject', createObject)
+        let _id = createObject.object[0]._id
 
-        let readDocument = await CoCreate.indexeddb.process({
-            method: 'read.object',
-            database: ['testDB', 'testDB1', 'testDB2'],
-            array: ['testCollection', 'testCollection1', 'testCollection2'],
+        let readObject = await CoCreate.indexeddb.process({
+            method: 'object.read',
+            database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
+            array: ['testArray', 'testArray1', 'testArray2'],
             object: {
                 _id,
             }
 
         })
-        console.log('readDocument', readDocument)
+        console.log('readObject', readObject)
 
-        let updateDocument = await CoCreate.indexeddb.process({
-            method: 'update.object',
-            database: ['testDB', 'testDB1', 'testDB2'],
-            array: ['testCollection', 'testCollection1', 'testCollection2'],
+        let updateObject = await CoCreate.indexeddb.process({
+            method: 'object.update',
+            database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
+            array: ['testArray', 'testArray1', 'testArray2'],
             object: {
                 _id,
                 'books.action.title': 'matr',
@@ -40,13 +40,13 @@ async function testDocuments() {
             }
 
         })
-        console.log('updateDocument', updateDocument)
+        console.log('updateObject', updateObject)
 
 
-        let deleteDocument = await CoCreate.indexeddb.process({
-            method: 'delete.object',
-            database: ['testDB', 'testDB1', 'testDB2'],
-            array: ['testCollection', 'testCollection1', 'testCollection2'],
+        let deleteObject = await CoCreate.indexeddb.process({
+            method: 'object.delete',
+            database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
+            array: ['testArray', 'testArray1', 'testArray2'],
             // object: {
             //     _id
             // }
@@ -58,10 +58,10 @@ async function testDocuments() {
 
 
         })
-        console.log('deleteDocument', deleteDocument)
+        console.log('deleteObject', deleteObject)
 
         // let deleteDatabase = await CoCreate.indexeddb.deleteDatabase({
-        //     database: ['testDB', 'testDB1', 'testDB2'],
+        //     database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
         // })
         // console.log('deleteDatabase', deleteDatabase)
     }

package/test/index.html

@@ -6,9 +6,9 @@
         <meta name="viewport" content="width=device-width, initial-scale=1" />
         <link
             rel="icon"
-            href="https://cdn.cocreate.app/favicon.ico"
-            type="image/ico"
-            sizes="16x16" />
+            type="image/png"
+            sizes="32x32"
+            href="../assets/favicon.ico" />
         <title>indexeddb | CoCreateJS</title>
         <link rel="manifest" href="/manifest.webmanifest" />
     </head>