@cocreate/indexeddb 1.16.2 → 1.17.1

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+## [1.17.1](https://github.com/CoCreate-app/CoCreate-indexeddb/compare/v1.17.0...v1.17.1) (2023-11-09)
+
+
+### Bug Fixes
+
+* $storage, $database, $array are arrays ([b6374f8](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/b6374f84e4ff13751cc357bbba8d4c883380083f))
+* meta name typo ([da33128](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/da331289589ea151f78ce25942e18e133f6b87f1))
+* update crud methods ([c74ed56](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/c74ed5688bd9a25f4eb524064b799ad678bdcc57))
+* updated date to ISO format with UTC timezone ([8bcc59a](https://github.com/CoCreate-app/CoCreate-indexeddb/commit/8bcc59a7d715937c6de139dcb12951a686aa1cff))
+
+# [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)
 
 

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/docs/index.html

@@ -11,10 +11,10 @@
             sizes="32x32"
             href="https://cocreate.app/images/favicon.ico" />
         <meta
-            key="description"
+            name="description"
             content="A simple HTML5 and pure javascript component. Easy configuration using data-attributes and highly styleable." />
         <meta
-            key="keywords"
+            name="keywords"
             content="helper classes, utility classes, css framework, css library, inline style classes" />
         <meta name="robots" content="index,follow" />
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/indexeddb",
-  "version": "1.16.2",
+  "version": "1.17.1",
   "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

@@ -22,9 +22,8 @@
  * For details, visit <https://cocreate.app/licenses/> or contact us at sales@cocreate.app
  */
 
-import { ObjectId, dotNotationToObject, searchData, sortData, queryData, isValidDate } from '@cocreate/utils'
+import { ObjectId, dotNotationToObject, searchData, sortData, queryData } from '@cocreate/utils'
 
-// let status = true;
 let indexedDbFunction
 
 function init() {
@@ -63,22 +62,15 @@ 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
-                data['timeStamp'] = new Date(data['timeStamp'])
+                data['timeStamp'] = new Date().toISOString();
 
             let databases = data.database;
             if (!databases && data.organization_id)
@@ -117,28 +109,25 @@ 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) {
                         let isFilter = queryData(database, data.$filter.query)
                         if (isFilter)
-                            newData.push({ $storage: 'indexeddb', ...database })
+                            newData.push({ $storage: ['indexeddb'], ...database })
                     } else
-                        newData.push({ $storage: 'indexeddb', ...database })
+                        newData.push({ $storage: ['indexeddb'], ...database })
                 }
 
                 resolve()
             })
         } else {
             let databases
-            if (data.method == 'update.database')
+            if (data.method == 'database.update')
                 databases = Object.keys(data.database)
             else
                 databases = data.database;
@@ -149,12 +138,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:
@@ -165,7 +154,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();
@@ -232,7 +221,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)
@@ -242,7 +231,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)
@@ -250,7 +239,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)
@@ -271,10 +260,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] = []
 
@@ -282,19 +271,19 @@ async function processArray(data, newData, database, type) {
             if (data.$filter && data.$filter.query) {
                 let isFilter = queryData({ name: objectStoreNames[i] }, data.$filter.query)
                 if (isFilter)
-                    newData.push({ name: objectStoreNames, $storage: 'indexeddb', $database: database })
+                    newData.push({ name: objectStoreNames, $storage: ['indexeddb'], $database: [database] })
             } else
-                newData.push({ name: objectStoreNames[i], $storage: 'indexeddb', $database: database })
+                newData.push({ name: objectStoreNames[i], $storage: ['indexeddb'], $database: [database] })
         }
     } 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];
@@ -305,20 +294,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);
 
@@ -327,12 +316,12 @@ 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'
                     }
 
                     if (!error)
-                        newData.push({ name: array, $storage: 'indexeddb', $database: database, array })
+                        newData.push({ name: array, $storage: ['indexeddb'], $database: [database] })
                     else
                         errorHandler(data, error, database)
 
@@ -355,7 +344,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
@@ -363,19 +352,19 @@ 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)
                     if (!(queryData({ name }, data.$filter.query))) continue
 
-                newData.push({ name, $storage: 'indexeddb', $database: database, $array: array })
+                newData.push({ name, $storage: ['indexeddb'], $database: [database], $array: [array] })
             }
             db.close()
         } else {
             db.close()
             let indexes
-            if (data.method == 'update.index')
+            if (data.method == 'index.update')
                 indexes = Object.keys(data[type])
             else
                 indexes = data[type];
@@ -385,20 +374,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]];
@@ -406,10 +395,10 @@ async function processIndex(data, newData, database, array, type) {
                             error = 'new index name already exist'
                     }
                 } else
-                    error = 'index does not exist'
+                    error = 'index does not exist';
 
                 if (!error)
-                    newData.push({ name: index, $storage: 'indexeddb', $database: database, $array: array })
+                    newData.push({ name: index, $storage: ['indexeddb'], $database: [database], $array: [array] })
                 else
                     errorHandler(data, error, database, array)
 
@@ -420,18 +409,23 @@ 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 })
 
     try {
+        if (!data[type])
+            data[type] = []
+        if (data[type] && !Array.isArray(data[type]))
+            data[type] = [data[type]]
+
         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') {
-                db.close()
-                db = await processDatabase({ method: 'get.database', database, array })
+            db.close()
+            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)
             }
@@ -440,16 +434,13 @@ async function processObject(data, newData, database, array, type) {
         if (!array || !db)
             throw new Error({ error: "This is an error message.", db, array });
 
-        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 transactionType = "readwrite" //test
-        if (data.method == 'read.object')
+        let transactionType = "readwrite"
+        if (data.method == 'object.read')
             transactionType = "readonly"
 
         let transaction = db.transaction([array], transactionType);
@@ -458,55 +449,45 @@ async function processObject(data, newData, database, array, type) {
         let globalOperators = getGlobalOperators(data)
         let upsert = data.upsert
 
-        if (data.$filter) {
-            let count = objectStore.count();
-            count.onsuccess = function () {
-                data.$filter.count = count.result
-            }
-        }
-
         for (let i = 0; i < data[type].length; i++) {
+            const reference = { $storage: ['indexeddb'], $database: [database], $array: [array] }
+
             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] = { ...reference, ...data[type][i] }
 
-                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
-                    data[type][i]['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
+                    // TODO: user_id || clientId shohould be retrieved from CoCreate
+                    if (!data[type][i].modified)
+                        data[type][i].modified = { on: data.timeStamp, by: data.user_id || data.clientId }
                 }
 
                 let index = 0, limit, range, direction
                 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;
 
@@ -545,26 +526,43 @@ 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
                 }
 
-                await openCursor(objectStore, range, direction, data, newData, isFilter, limit, database, array, upsert, type, i, globalOperators);
+                await openCursor(objectStore, range, direction, data, newData, isFilter, limit, database, array, upsert, type, i, globalOperators, reference);
 
                 if (index)
                     newData = newData.slice(index)
@@ -583,22 +581,22 @@ async function processObject(data, newData, database, array, type) {
     }
 }
 
-function openCursor(objectStore, range, direction, data, newData, isFilter, limit, database, array, upsert, type, i, globalOperators) {
+function openCursor(objectStore, range, direction, data, newData, isFilter, limit, database, array, upsert, type, i, globalOperators, reference) {
     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
                 }
 
@@ -610,20 +608,17 @@ 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] = { ...reference, ...data[type][i] }
+
+                    matchedLength++
 
-                    if (result)
-                        newData.push({ $storage: 'indexeddb', $database: database, $array: array, ...result })
                 }
                 resolve();
             } else if (cursor) {
@@ -634,7 +629,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)
@@ -643,15 +638,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] = { ...reference, ...result }
+                    else {
+                        let object = data[type].find(obj => obj._id && obj._id === result._id)
+                        if (object)
+                            object = { ...reference, ...object, ...result }
+                        else
+                            newData.push({ ...reference, ...result })
+                    }
+
+                    matchedLength++
                 }
 
-                if (!limit || limit && limit < newData.length) {
+                if (!limit || limit && (limit < newData.length || limit < matchedLength)) {
                     cursor.continue();
                 } else if (cursor.close) {
                     cursor.close()
@@ -659,6 +664,7 @@ function openCursor(objectStore, range, direction, data, newData, isFilter, limi
                 } else {
                     resolve();
                 }
+
             } else {
                 resolve();
             }
@@ -711,15 +717,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)
@@ -781,7 +778,6 @@ function createUpdate(update, data, globalOpertors) {
 function dotNotationToObjectUpdate(data, object = {}) {
     try {
         for (const key of Object.keys(data)) {
-            let value = isValidDate(data[key])
             let newObject = object
             let oldObject = new Object(newObject)
             let keys = key.replace(/\[(\d+)\]/g, '.$1').split('.');
@@ -854,18 +850,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 Coindex.createeddb.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 Coindex.createeddb.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 Coindex.createeddb.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 Coindex.createeddb.process({
+            method: 'array.delete',
+            database: ['testDatabase', 'testDatabase1', 'testDatabase2'],
+            array: ['testArrayA', 'testArray1', 'testArray2']
         })
-        console.log('deleteCollection', deleteCollection)
+        console.log('deleteObject', deleteObject)
 
     }
 }

package/test/databases.js

@@ -3,27 +3,27 @@ async function testDatabases() {
         console.log("This browser doesn't support IndexedDB.");
         return;
     } else {
-        let createDatabase = await CoCreate.indexeddb.process({
-            method: 'create.database',
+        let createDatabase = await Coindex.createeddb.process({
+            method: 'database.create',
             database: 'testDB',
         })
         console.log('createDatabase', createDatabase)
 
-        let readDatabase = await CoCreate.indexeddb.process({
-            method: 'read.database',
+        let readDatabase = await Coindex.createeddb.process({
+            method: 'database.read',
             database: 'testDB',
         })
         console.log('readDatabase', readDatabase)
 
-        let updateDatabase = await CoCreate.indexeddb.process({
-            method: 'update.database',
+        let updateDatabase = await Coindex.createeddb.process({
+            method: 'database.update',
             database: { testDB: 'testDatabase1' }
         })
         console.log('updateDatabase', updateDatabase)
 
 
-        let deleteDatabase = await CoCreate.indexeddb.process({
-            method: 'delete.database',
+        let deleteDatabase = await Coindex.createeddb.process({
+            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 Coindex.createeddb.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 Coindex.createeddb.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 Coindex.createeddb.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 Coindex.createeddb.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'],
+        // let deleteDatabase = await Coindex.createeddb.deleteDatabase({
+        //     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>

package/test/indexes.js

@@ -3,7 +3,7 @@ async function testIndexes() {
         console.log("This browser doesn't support IndexedDB.");
         return;
     } else {
-        let createIndexes = await CoCreate.indexeddb.createIndex({
+        let createIndexes = await Coindex.createeddb.createIndex({
             database: ['testDB', 'testDB1', 'testDB2'],
             array: ['testCollection', 'testCollection1', 'testCollection2'],
             index: 'testIndexes'
@@ -11,20 +11,20 @@ async function testIndexes() {
         })
         console.log('createIndexes', createIndexes)
 
-        let readIndexes = await CoCreate.indexeddb.readIndex({
+        let readIndexes = await Coindex.createeddb.readIndex({
             database: ['testDB', 'testDB1', 'testDB2'],
             array: ['testCollection', 'testCollection1', 'testCollection2']
         })
         console.log('readIndexes', readIndexes)
 
-        let updateIndexes = await CoCreate.indexeddb.updateIndex({
+        let updateIndexes = await Coindex.createeddb.updateIndex({
             database: ['testDB', 'testDB1', 'testDB2'],
             array: ['testCollection', 'testCollection1', 'testCollection2'],
             index: { testIndexes: 'testIndexes1' }
         })
         console.log('updateIndexes', updateIndexes)
 
-        let deleteIndexes = await CoCreate.indexeddb.deleteIndex({
+        let deleteIndexes = await Coindex.createeddb.deleteIndex({
             database: ['testDB', 'testDB1', 'testDB2'],
             array: ['testCollection', 'testCollection1', 'testCollection2'],
             index: 'testIndexes1'