@cocreate/indexeddb 1.22.5 → 1.23.0

package/src/index.js

@@ -22,769 +22,859 @@
  * For details, visit <https://cocreate.app/licenses/> or contact us at sales@cocreate.app
  */
 
-import { ObjectId, dotNotationToObject, searchData, sortData, queryData, createUpdate, isEqualArray, isEqualObject } from '@cocreate/utils'
-
-let indexedDbFunction
+import {
+  ObjectId,
+  dotNotationToObject,
+  searchData,
+  sortData,
+  queryData,
+  createUpdate,
+  isEqualArray,
+  isEqualObject,
+} from "@cocreate/utils";
+
+let indexedDbFunction;
 
 function init() {
-    // Check for support.
-    if (!('indexedDB' in window)) {
-        console.log("This browser doesn't support IndexedDB.");
-        setStatus(false);
-        return;
-    } else {
-        try {
-            indexedDB.databases()
-            if (window.CoCreateConfig && window.CoCreateConfig.indexeddb !== false)
-                setStatus(true)
-        } catch (e) {
-            setStatus(false);
-        }
+  // Check for support.
+  if (!("indexedDB" in window)) {
+    console.log("This browser doesn't support IndexedDB.");
+    setStatus(false);
+    return;
+  } else {
+    try {
+      indexedDB.databases();
+      if (window.CoCreateConfig && window.CoCreateConfig.indexeddb !== false)
+        setStatus(true);
+    } catch (e) {
+      setStatus(false);
     }
+  }
 }
 
 function setStatus(value) {
-    if (window.CoCreateConfig)
-        window.CoCreateConfig.indexeddb = value;
-    else
-        window.CoCreateConfig = { indexeddb: value };
-
-    if (!value) {
-        indexedDbFunction = indexedDb
-        send = value;
-    } else if (!send) {
-        send = indexedDbFunction
-        indexedDbFunction = true
-    }
+  if (window.CoCreateConfig) window.CoCreateConfig.indexeddb = value;
+  else window.CoCreateConfig = { indexeddb: value };
+
+  if (!value) {
+    indexedDbFunction = indexedDb;
+    send = value;
+  } else if (!send) {
+    send = indexedDbFunction;
+    indexedDbFunction = true;
+  }
 }
 
 async function send(data) {
-    try {
-        let newData = [];
-
-        let type = data.method.split('.')[0];
-        if (type === 'database') {
-            if (data.method === 'database.get') {
-                return await processDatabase(data)
-            } else
-                await processDatabase(data, newData, type)
-        } else {
-            if (!data['timeStamp'])
-                data['timeStamp'] = new Date().toISOString();
-
-            let databases = data.database;
-            if (!databases && data.organization_id)
-                databases = [data.organization_id]
-            if (!Array.isArray(databases))
-                databases = [databases]
-
-            let arrays = data.array || [];
-            if (!Array.isArray(arrays))
-                arrays = [arrays]
-
-            for (let i = 0; i < databases.length; i++) {
-                let database = databases[i]
-                if (type === 'array') {
-                    await processArray(data, newData, database, type)
-                } else {
-                    for (let j = 0; j < arrays.length; j++) {
-                        if (type === 'index')
-                            await processIndex(data, newData, database, type)
-                        else if (type === 'object')
-                            await processObject(data, newData, database, arrays[j], type)
-                    }
-                }
-            }
-        }
+  try {
+    let newData = [];
+
+    let type = data.method.split(".")[0];
+    if (type === "database") {
+      if (data.method === "database.get") {
+        return await processDatabase(data);
+      } else await processDatabase(data, newData, type);
+    } else {
+      if (!data["timeStamp"]) data["timeStamp"] = new Date().toISOString();
 
-        return createData(data, newData, type)
+      let databases = data.database;
+      if (!databases && data.organization_id)
+        databases = [data.organization_id];
+      if (!Array.isArray(databases)) databases = [databases];
 
-    } catch (error) {
-        errorHandler(data, error)
-    }
-}
-
-const dbVersion = new Map()
-const processDatabase = (data, newData, type) => {
-    return new Promise((resolve, reject) => {
-        if (!data)
-            data = {}
-        if (!data[type])
-            data[type] = []
-
-        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 })
-                    } else
-                        newData.push({ $storage: ['indexeddb'], ...database })
-                }
+      let arrays = data.array || [];
+      if (!Array.isArray(arrays)) arrays = [arrays];
 
-                resolve()
-            })
+      for (let i = 0; i < databases.length; i++) {
+        let database = databases[i];
+        if (type === "array") {
+          await processArray(data, newData, database, type);
         } else {
-            let databases
-            if (data.method == 'database.update')
-                databases = Object.keys(data.database)
-            else
-                databases = data.database;
-
-            if (!Array.isArray(databases))
-                databases = [databases]
-
-            for (let i = 0; i < databases.length; i++) {
-                let openRequest, database = databases[i];
-                switch (data.method) {
-                    case 'database.get':
-                    case 'database.create':
-                    case 'database.update':
-                        openRequest = indexedDB.open(database);
-                        break;
-                    case 'database.delete':
-                        openRequest = indexedDB.deleteprocessDatabase(database);
-                        break;
-                    default:
-                        errorHandler(data, 'unknown method', database)
-                        resolve(data)
-                }
-
-                openRequest.onsuccess = function () {
-                    let db = openRequest.result;
-
-                    if (data.method == 'database.update') {
-                        let objectStoreNames = Array.from(db.objectStoreNames)
-                        for (let array of objectStoreNames) {
-                            let request = array.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, array)
-                            };
-
-                        }
-
-                    } else if (data.upgrade === true) {
-                        db.close()
-
-                        let version = dbVersion.get(database) || openRequest.result.version
-                        resolve(indexedDB.open(database, Number(version += 1)))
-                        dbVersion.set(database, version)
-
-                    } else if (data.array) {
-                        db.close()
-
-                        let version = dbVersion.get(database) || openRequest.result.version
-                        let request = indexedDB.open(database, Number(version += 1));
-                        dbVersion.set(database, version)
-
-                        request.onupgradeneeded = function (event) {
-                            const db = event.target.result;
-
-                            let arrays = data.array;
-                            if (!Array.isArray(arrays))
-                                arrays = [arrays]
-
-                            for (let j = 0; j < arrays.length; j++) {
-                                if (!db.objectStoreNames.contains(arrays[j])) {
-                                    try {
-                                        db.createObjectStore(arrays[j], { keyPath: '_id', autoIncrement: true });
-                                    } catch (error) {
-                                        errorHandler(data, error, database, arrays[j])
-                                    }
-                                }
-
-                                if (data.indexName) {
-                                    let index = data.indexName;
-                                    if (!Array.isArray(index))
-                                        index = [index]
-                                    for (let k = 0; k < index.length; k++) {
-                                        const transaction = event.target.transaction;
-                                        const objectStore = transaction.objectStore(arrays[j]);
-                                        objectStore.createIndex(index[k], index[k], { unique: data.unique || false });
-                                    }
-                                }
-                            }
-                        };
-
-                        request.onsuccess = function (event) {
-                            if (databases.length - 1 === i) {
-                                if (data.method == 'database.get')
-                                    resolve(event.target.result)
-                                else
-                                    resolve(data)
-                            }
-                        };
-
-                        request.onerror = function (event) {
-                            errorHandler(data, event.target.error, database, array)
-                            if (databases.length - 1 === i) {
-                                if (data.method == 'database.get')
-                                    resolve(event.target.result)
-                                else
-                                    resolve(data)
-                            }
-                        };
-
-                    } else if (databases.length - 1 === i) {
-                        if (data.method == 'database.get')
-                            resolve(db)
-                        else
-                            resolve(data)
-                    }
-                };
-
-                openRequest.onerror = function () {
-                    errorHandler(data, openRequest.error, database)
-                    resolve(data)
-                };
-
-            }
+          for (let j = 0; j < arrays.length; j++) {
+            if (type === "index")
+              await processIndex(data, newData, database, type);
+            else if (type === "object")
+              await processObject(data, newData, database, arrays[j], type);
+          }
         }
+      }
+    }
 
-    }, (error) => {
-        errorHandler(data, error)
-    });
+    return createData(data, newData, type);
+  } catch (error) {
+    errorHandler(data, error);
+  }
 }
 
-async function processArray(data, newData, database, type) {
-    let db = await processDatabase({ method: 'database.get', database })
-
-    let objectStoreNames = Array.from(db.objectStoreNames)
-    if (data.method == 'array.read') {
-        if (!data[type])
-            data[type] = []
-
-        for (let i = 0; i < objectStoreNames.length; i++) {
+const dbVersion = new Map();
+const processDatabase = (data, newData, type) => {
+  return new Promise(
+    (resolve, reject) => {
+      if (!data) data = {};
+      if (!data[type]) data[type] = [];
+
+      if (data.method == "database.read") {
+        indexedDB.databases().then((databases) => {
+          for (let database of databases) {
             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] })
-            } else
-                newData.push({ name: objectStoreNames[i], $storage: ['indexeddb'], $database: [database] })
-        }
-    } else {
-        db.close()
-
-        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 == 'array.update')
-                    arrays = Object.keys(data[type])
-                else
-                    arrays = data[type];
-                if (!Array.isArray(arrays))
-                    arrays = [arrays]
-
-                for (let i = 0; i < arrays.length; i++) {
-                    let error, array = arrays[i]
-
-                    let arrayExist = db.objectStoreNames.contains(array)
-                    if (arrayExist && data.method == 'array.create') {
-                        error = 'array already exists'
-                    } 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 == 'array.update')
-                            array = data[type][arrays[i]]
-
-                        if (arrayExist) {
-                            if (data.method == 'array.update') {
-                                let transaction = event.target.transaction;
-                                let objectStore = transaction.objectStore(array);
-
-                                if (!objectStoreNames.includes(data[type][arrays[i]]))
-                                    array = objectStore.name = data[type][arrays[i]];
-                                else
-                                    error = 'An array with the new name already exist'
-                            }
-                        } else if (data.method == 'array.update')
-                            error = 'array does not exists'
-                    }
-
-                    if (!error)
-                        newData.push({ name: array, $storage: ['indexeddb'], $database: [database] })
-                    else
-                        errorHandler(data, error, database)
-
-                }
-            };
-
-            request.onsuccess = function (event) {
-                event.target.result.close()
-                resolve()
-            };
-
-            request.onerror = function (event) {
-                errorHandler(data, event.target.error, database)
-                resolve()
-            };
-
+              let isFilter = queryData(database, data.$filter.query);
+              if (isFilter)
+                newData.push({ $storage: ["indexeddb"], ...database });
+            } else newData.push({ $storage: ["indexeddb"], ...database });
+          }
 
+          resolve();
         });
-    }
-}
-
-async function processIndex(data, newData, database, array, type) {
-    let db = await processDatabase({ method: 'database.get', database })
-    let arrayExist = db.objectStoreNames.contains(array)
-    if (arrayExist) {
-        // ToDO: switch here to types
-        let transaction = db.transaction(array, "readonly");
-        let objectStore = transaction.objectStore(array);
-        let indexNames = Array.from(objectStore.indexNames)
-
-        if (data.method == '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
+      } else {
+        let databases;
+        if (data.method == "database.update")
+          databases = Object.keys(data.database);
+        else databases = data.database;
+
+        if (!Array.isArray(databases)) databases = [databases];
+
+        for (let i = 0; i < databases.length; i++) {
+          let openRequest,
+            database = databases[i];
+          switch (data.method) {
+            case "database.get":
+            case "database.create":
+            case "database.update":
+              openRequest = indexedDB.open(database);
+              break;
+            case "database.delete":
+              openRequest = indexedDB.deleteprocessDatabase(database);
+              break;
+            default:
+              errorHandler(data, "unknown method", database);
+              resolve(data);
+          }
+
+          openRequest.onsuccess = function () {
+            let db = openRequest.result;
+
+            if (data.method == "database.update") {
+              let objectStoreNames = Array.from(db.objectStoreNames);
+              for (let array of objectStoreNames) {
+                let request = array.openCursor();
+
+                request.onsuccess = function () {
+                  let cursor = request.result;
+                  if (cursor) {
+                    let value = cursor.value;
+
+                    cursor.continue();
+                  } else {
+                    // -1
+                  }
+                };
 
-                newData.push({ name, $storage: ['indexeddb'], $database: [database], $array: [array] })
-            }
-            db.close()
-        } else {
-            db.close()
-            let indexes
-            if (data.method == 'index.update')
-                indexes = Object.keys(data[type])
-            else
-                indexes = data[type];
-
-            if (!Array.isArray(indexes))
-                indexes = [indexes]
-
-            for (let i = 0; i < indexes.length; i++) {
-                let error, index = indexes[i]
-                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 == 'index.create') {
-                    if (!indexExist)
-                        objectStore.createIndex(index, index, { unique: false })
-                    else
-                        error = 'index already exist'
-                } else if (indexExist) {
-                    if (data.method == 'index.delete')
-                        objectStore.deleteIndex(index)
-                    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]];
-                        } else
-                            error = 'new index name already exist'
+                request.onerror = function () {
+                  errorHandler(data, request.error, database, array);
+                };
+              }
+            } else if (data.upgrade === true) {
+              db.close();
+
+              let version =
+                dbVersion.get(database) || openRequest.result.version;
+              resolve(indexedDB.open(database, Number((version += 1))));
+              dbVersion.set(database, version);
+            } else if (data.array) {
+              db.close();
+
+              let version =
+                dbVersion.get(database) || openRequest.result.version;
+              let request = indexedDB.open(database, Number((version += 1)));
+              dbVersion.set(database, version);
+
+              request.onupgradeneeded = function (event) {
+                const db = event.target.result;
+
+                let arrays = data.array;
+                if (!Array.isArray(arrays)) arrays = [arrays];
+
+                for (let j = 0; j < arrays.length; j++) {
+                  if (!db.objectStoreNames.contains(arrays[j])) {
+                    try {
+                      db.createObjectStore(arrays[j], {
+                        keyPath: "_id",
+                        autoIncrement: true,
+                      });
+                    } catch (error) {
+                      errorHandler(data, error, database, arrays[j]);
                     }
-                } else
-                    error = 'index does not exist';
-
-                if (!error)
-                    newData.push({ name: index, $storage: ['indexeddb'], $database: [database], $array: [array] })
-                else
-                    errorHandler(data, error, database, array)
+                  }
+
+                  if (data.indexName) {
+                    const transaction = event.target.transaction;
+                    const objectStore = transaction.objectStore(arrays[j]);
+                    if (!objectStore.indexNames.contains(data.indexName))
+                      objectStore.createIndex(
+                        data.indexName,
+                        data.indexFields,
+                        { unique: data.unique || false }
+                      );
+                  }
+                }
+              };
 
-                db.result.close()
+              request.onsuccess = function (event) {
+                if (databases.length - 1 === i) {
+                  if (data.method == "database.get")
+                    resolve(event.target.result);
+                  else resolve(data);
+                }
+              };
+
+              request.onerror = function (event) {
+                errorHandler(data, event.target.error, database, array);
+                if (databases.length - 1 === i) {
+                  if (data.method == "database.get")
+                    resolve(event.target.result);
+                  else resolve(data);
+                }
+              };
+            } else if (databases.length - 1 === i) {
+              if (data.method == "database.get") resolve(db);
+              else resolve(data);
             }
+          };
+
+          openRequest.onerror = function () {
+            errorHandler(data, openRequest.error, database);
+            resolve(data);
+          };
         }
+      }
+    },
+    (error) => {
+      errorHandler(data, error);
     }
-}
+  );
+};
 
-async function processObject(data, newData, database, array, type) {
-    let db = await processDatabase({ method: 'database.get', database })
+async function processArray(data, newData, database, type) {
+  let db = await processDatabase({ method: "database.get", database });
+
+  let objectStoreNames = Array.from(db.objectStoreNames);
+  if (data.method == "array.read") {
+    if (!data[type]) data[type] = [];
+
+    for (let i = 0; i < objectStoreNames.length; i++) {
+      if (data.$filter && data.$filter.query) {
+        let isFilter = queryData(
+          { name: objectStoreNames[i] },
+          data.$filter.query
+        );
+        if (isFilter)
+          newData.push({
+            name: objectStoreNames,
+            $storage: ["indexeddb"],
+            $database: [database],
+          });
+      } else
+        newData.push({
+          name: objectStoreNames[i],
+          $storage: ["indexeddb"],
+          $database: [database],
+        });
+    }
+  } else {
+    db.close();
 
-    try {
-        if (!data[type])
-            data[type] = []
-        else if (typeof data[type] === 'string')
-            data[type] = [{ _id: data[type] }]
-        else if (!Array.isArray(data[type]))
-            data[type] = [data[type]]
-
-        let isFilter
-        if (data.$filter)
-            isFilter = true
-
-        let arrayExist = db.objectStoreNames.contains(array)
-        if (!arrayExist) {
-            db.close()
-            if (data.method == 'object.create' || data.method == 'object.update') {
-                db = await processDatabase({ method: 'database.get', database, array })
+    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 == "array.update") arrays = Object.keys(data[type]);
+        else arrays = data[type];
+        if (!Array.isArray(arrays)) arrays = [arrays];
+
+        for (let i = 0; i < arrays.length; i++) {
+          let error,
+            array = arrays[i];
+
+          let arrayExist = db.objectStoreNames.contains(array);
+          if (arrayExist && data.method == "array.create") {
+            error = "array already exists";
+          } else if (data.method == "array.delete") {
+            if (objectStoreNames.includes(array)) {
+              db.deleteObjectStore(array);
             } else {
-                return errorHandler(data, "array does not exist", database, array)
+              error = "the array does not exist";
             }
-        }
+          } else {
+            if (!arrayExist && data.method == "array.update")
+              array = data[type][arrays[i]];
 
-        if (!array || !db)
-            throw new Error({ error: "This is an error message.", db, array });
+            if (arrayExist) {
+              if (data.method == "array.update") {
+                let transaction = event.target.transaction;
+                let objectStore = transaction.objectStore(array);
 
+                if (!objectStoreNames.includes(data[type][arrays[i]]))
+                  array = objectStore.name = data[type][arrays[i]];
+                else error = "An array with the new name already exist";
+              }
+            } else if (data.method == "array.update")
+              error = "array does not exists";
+          }
+
+          if (!error)
+            newData.push({
+              name: array,
+              $storage: ["indexeddb"],
+              $database: [database],
+            });
+          else errorHandler(data, error, database);
+        }
+      };
 
-        if ((isFilter && !data[type].length) || data.isFilter)
-            data[type] = [{ isFilter: 'isEmptyObjectFilter' }];
-        // data[type].splice(0, 0, { isFilter: 'isEmptyObjectFilter' });
+      request.onsuccess = function (event) {
+        event.target.result.close();
+        resolve();
+      };
 
-        let transactionType = "readwrite"
-        if (data.method == 'object.read')
-            transactionType = "readonly"
+      request.onerror = function (event) {
+        errorHandler(data, event.target.error, database);
+        resolve();
+      };
+    });
+  }
+}
 
-        let transaction = db.transaction([array], transactionType);
+async function processIndex(data, newData, database, array, type) {
+  let db = await processDatabase({ method: "database.get", database });
+  let arrayExist = db.objectStoreNames.contains(array);
+  if (arrayExist) {
+    // ToDO: switch here to types
+    let transaction = db.transaction(array, "readonly");
+    let objectStore = transaction.objectStore(array);
+    let indexNames = Array.from(objectStore.indexNames);
+
+    if (data.method == "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],
+        });
+      }
+      db.close();
+    } else {
+      db.close();
+      let indexes;
+      if (data.method == "index.update") indexes = Object.keys(data[type]);
+      else indexes = data[type];
+
+      if (!Array.isArray(indexes)) indexes = [indexes];
+
+      for (let i = 0; i < indexes.length; i++) {
+        let error,
+          index = indexes[i];
+        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 == "index.create") {
+          if (!indexExist)
+            objectStore.createIndex(index, index, { unique: false });
+          else error = "index already exist";
+        } else if (indexExist) {
+          if (data.method == "index.delete") objectStore.deleteIndex(index);
+          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]];
+            } else error = "new index name already exist";
+          }
+        } else error = "index does not exist";
+
+        if (!error)
+          newData.push({
+            name: index,
+            $storage: ["indexeddb"],
+            $database: [database],
+            $array: [array],
+          });
+        else errorHandler(data, error, database, array);
+
+        db.result.close();
+      }
+    }
+  }
+}
 
-        let globalOperators = getGlobalOperators(data)
-        let upsert = data.upsert
-
-        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 == '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] }
-
-            } else {
-                if (data[type][i].$filter)
-                    isFilter = true
-
-                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
-                    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) {
-                    let isIndex = false
-                    let indexName, direction;
-
-                    if (data.$filter) {
-                        if (data.$filter.sort && data.$filter.sort[0] && data.$filter.sort[0].key) {
-                            indexName = data.$filter.sort[0].key
-                            if (indexName.includes('-'))
-                                isIndex = false
-                            else
-                                isIndex = true
-
-                            direction = data.$filter.sort[0].direction
-                            if (direction == 'desc')
-                                direction = 'prev'
-                            else
-                                direction = 'next'
-
-                        } else if (data.$filter.query && data.$filter.query[0] && data.$filter.query[0].key && data.$filter.query[0].index) {
-                            if (data.$filter.query[0].operator === '$eq')
-                                range = IDBKeyRange.only(data.$filter.query[0].value);
-                            else if (data.$filter.query[0].operator === '$gt')
-                                range = IDBKeyRange.lowerBound(data.$filter.query[0].value, true);
-                            else if (data.$filter.query[0].operator === '$lt')
-                                range = IDBKeyRange.upperBound(data.$filter.query[0].value, true);
-
-                            indexName = data.$filter.query[0].key
-                            if (indexName.includes('-'))
-                                isIndex = false
-                            else
-                                isIndex = true
-                        }
-                    }
+async function processObject(data, newData, database, array, type) {
+  let db = await processDatabase({ method: "database.get", database });
+
+  try {
+    if (!data[type]) data[type] = [];
+    else if (typeof data[type] === "string") data[type] = [{ _id: data[type] }];
+    else if (!Array.isArray(data[type])) data[type] = [data[type]];
+
+    let isFilter;
+    if (data.$filter) isFilter = true;
+
+    let arrayExist = db.objectStoreNames.contains(array);
+    if (!arrayExist) {
+      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);
+      }
+    }
 
-                    if (isIndex) {
-                        let indexNames = Array.from(objectStore.indexNames)
-                        let indexExist = indexNames.includes(indexName)
-                        if (!indexExist) {
-                            db.close()
-                            db = await processDatabase({ method: 'database.get', database, array, indexName })
-                            transaction = db.transaction(array, 'readwrite');
-                            objectStore = transaction.objectStore(array);
-                        }
-                        objectStore = objectStore.index(indexName);
-                    }
+    if (!array || !db)
+      throw new Error({ error: "This is an error message.", db, array });
 
-                    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
-                    }
+    let lastItem;
+    if ((isFilter && !data[type].length) || data.isFilter) {
+      if (data[type].length) lastItem = data[type][data[type].length - 1];
+      data[type] = [{ isFilter: "isEmptyObjectFilter" }];
 
-                    if (data.$filter) {
-                        if (data.$filter.index)
-                            index = data.$filter.index
-                        if (data.$filter.limit)
-                            limit = data.$filter.limit
-                    }
+      // data[type].splice(0, 0, { isFilter: 'isEmptyObjectFilter' });
+    }
 
-                    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
-                    }
+    let transactionType = "readwrite";
+    if (data.method == "object.read") transactionType = "readonly";
+
+    let transaction = db.transaction([array], transactionType);
+    let objectStore = transaction.objectStore(array);
+
+    let globalOperators = getGlobalOperators(data);
+    let upsert = data.upsert;
+
+    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 == "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] };
+      } else {
+        if (data[type][i].$filter) isFilter = true;
+
+        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
+          if (!data[type][i].modified)
+            data[type][i].modified = {
+              on: data.timeStamp,
+              by: data.user_id || data.clientId,
+            };
+        }
 
-                } else if (data.method == 'object.delete' || data.method == 'object.update' && !range && !upsert && !isFilter) {
-                    continue
+        let index = 0,
+          limit,
+          range,
+          direction;
+        if (data[type][i]._id) {
+          range = IDBKeyRange.only(data[type][i]._id);
+        } else if (isFilter) {
+          let indexName;
+          let indexFields;
+
+          if (data.$filter) {
+            // TODO: requires a more robust sorting thats suports various directions
+            // Build compound index name from sort keys
+            if (data.$filter.sort && data.$filter.sort.length > 0) {
+              // Create a standard index name without _id
+              let sortKeys = data.$filter.sort
+                .map((sort) => sort.key)
+                .filter((key) => key !== "_id");
+              indexName = sortKeys.join("_"); // e.g., "createdAt_category"
+
+              // Define compound index fields
+              indexFields = [...sortKeys];
+
+              // Set cursor direction based on the first sort key direction
+              direction =
+                data.$filter.sort[0].direction === "desc" ? "prev" : "next";
+
+              // Use last item's values, including _id, to set up the range for pagination
+              if (indexName && lastItem && lastItem._id) {
+                indexName += "_id";
+                indexFields.push("_id");
+                let lastKeyValues = [
+                  ...sortKeys.map((key) => lastItem[key]),
+                  lastItem._id,
+                ]; // Compound key array with _id
+
+                // Create IDBKeyRange based on direction and lastKeyValues
+                if (direction === "next") {
+                  range = IDBKeyRange.lowerBound(lastKeyValues, true);
+                } else {
+                  range = IDBKeyRange.upperBound(lastKeyValues, true);
                 }
-
-                await openCursor(objectStore, range, direction, data, newData, isFilter, index, limit, database, array, upsert, type, i, globalOperators, reference);
-
-                if (index)
-                    newData = newData.slice(index)
+              }
+            } else if (
+              data.$filter.query &&
+              data.$filter.query[0] &&
+              data.$filter.query[0].key
+            ) {
+              if (data.$filter.query[0].operator === "$eq") {
+                range = IDBKeyRange.only(data.$filter.query[0].value);
+              } else if (data.$filter.query[0].operator === "$gt") {
+                range = IDBKeyRange.lowerBound(
+                  data.$filter.query[0].value,
+                  true
+                );
+              } else if (data.$filter.query[0].operator === "$lt") {
+                range = IDBKeyRange.upperBound(
+                  data.$filter.query[0].value,
+                  true
+                );
+              } else if (data.$filter.query[0].operator === "$gte") {
+                range = IDBKeyRange.lowerBound(data.$filter.query[0].value);
+              } else if (data.$filter.query[0].operator === "$lte") {
+                range = IDBKeyRange.upperBound(data.$filter.query[0].value);
+              }
+
+              indexName = data.$filter.query[0].key;
             }
-
+          }
+
+          if (indexName && !indexName.includes("-")) {
+            // Check if the compound index exists; create it if not
+            let indexNames = Array.from(objectStore.indexNames);
+            if (!indexNames.includes(indexName)) {
+              db.close();
+              db = await processDatabase({
+                method: "database.get",
+                database,
+                array,
+                indexName,
+                indexFields,
+              });
+              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 (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;
+          }
+        } else if (
+          data.method == "object.delete" ||
+          (data.method == "object.update" && !range && !upsert && !isFilter)
+        ) {
+          continue;
         }
 
-        if (db.close)
-            db.close()
-
-    } catch (error) {
-        errorHandler(data, error, database, array)
-        if (db.close)
-            db.close()
-
+        await openCursor(
+          objectStore,
+          range,
+          direction,
+          data,
+          newData,
+          isFilter,
+          index,
+          limit,
+          database,
+          array,
+          upsert,
+          type,
+          i,
+          globalOperators,
+          reference
+        );
+
+        if (index) newData = newData.slice(index);
+      }
     }
-}
-
-function openCursor(objectStore, range, direction, data, newData, isFilter, index, 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, matchedLength = 0, hasSkipped
-        request.onsuccess = async () => {
-            let cursor = request.result
-
-            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 === 'object.update' && !upsert)
-                        isMatch = false
-                }
-
-                if (isMatch !== false) {
-                    try {
-                        data[type][i]._id = ObjectId(data[type][i]._id).toString();
-                    } catch (error) {
-                        data[type][i]._id = ObjectId().toString()
-                    }
 
-                    let result
-                    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) {
-                            await put(objectStore, update)
-                            data[type][i].$update = update
-                        }
-                    }
-                    data[type][i] = { ...reference, ...data[type][i] }
-
-                    matchedLength++
-
-                }
-                resolve();
-            } else if (cursor) {
-                if (index && !hasSkipped) {
-                    cursor.advance(index);
-                    hasSkipped = true;
-                } else {
-                    let isMatch = true
-                    if (isFilter)
-                        isMatch = filter(objectStore, data, data[type][i], cursor.value)
-
-                    if (isMatch !== false) {
-                        let result = cursor.value
-
-                        if (data.method == 'object.update') {
-                            let update = createUpdate(cursor.value, data[type][i], globalOperators)
-                            if (update)
-                                await cursorUpdate(cursor, update)
-                            result = data[type][i]
-                            result.$update = update
-                            // result = cursor.update(update)
-                            hasUpdated = true
-                            // set dotnotation for keys with $operators for items that end in [] to be used by socket.id
-                            // 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 == 'object.delete') {
-                            result = cursor.value
-                            cursor.delete()
-                        }
-
-                        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 })
-                        }
-                    }
+    if (db.close) db.close();
+  } catch (error) {
+    errorHandler(data, error, database, array);
+    if (db.close) db.close();
+  }
+}
 
-                    if (!limit || limit && (limit > newData.length + matchedLength)) {
-                        cursor.continue();
-                    } else {
-                        resolve();
-                    }
-                }
+function openCursor(
+  objectStore,
+  range,
+  direction,
+  data,
+  newData,
+  isFilter,
+  index,
+  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,
+      matchedLength = 0,
+      hasSkipped;
+    request.onsuccess = async () => {
+      let cursor = request.result;
+
+      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 === "object.update" && !upsert) isMatch = false;
+        }
 
-            } else {
-                resolve();
+        if (isMatch !== false) {
+          try {
+            data[type][i]._id = ObjectId(data[type][i]._id).toString();
+          } catch (error) {
+            data[type][i]._id = ObjectId().toString();
+          }
+
+          let result;
+          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) {
+              await put(objectStore, update);
+              data[type][i].$update = update;
             }
+          }
+          data[type][i] = { ...reference, ...data[type][i] };
 
+          matchedLength++;
         }
+        resolve();
+      } else if (cursor) {
+        if (index && !hasSkipped) {
+          cursor.advance(index);
+          hasSkipped = true;
+        } else {
+          let isMatch = true;
+          if (isFilter)
+            isMatch = filter(objectStore, data, data[type][i], cursor.value);
+
+          if (isMatch !== false) {
+            let result = cursor.value;
+
+            if (data.method == "object.update") {
+              let update = createUpdate(
+                cursor.value,
+                data[type][i],
+                globalOperators
+              );
+              if (update) await cursorUpdate(cursor, update);
+              result = data[type][i];
+              result.$update = update;
+              // result = cursor.update(update)
+              hasUpdated = true;
+              // set dotnotation for keys with $operators for items that end in [] to be used by socket.id
+              // 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 == "object.delete") {
+              result = cursor.value;
+              cursor.delete();
+            }
 
-        request.onerror = () => {
-            reject(request.error)
+            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 });
+            }
+          }
+
+          if (!limit || (limit && limit > newData.length + matchedLength)) {
+            cursor.continue();
+          } else {
+            resolve();
+          }
         }
-    });
+      } else {
+        resolve();
+      }
+    };
+
+    request.onerror = () => {
+      reject(request.error);
+    };
+  });
 }
 
 function add(objectStore, object) {
-    return new Promise((resolve, reject) => {
-        const store = objectStore.objectStore || objectStore
-        let request = store.add(object);
-        request.onsuccess = () => resolve(object);
-        request.onerror = () => reject(request.error);
-    });
+  return new Promise((resolve, reject) => {
+    const store = objectStore.objectStore || objectStore;
+    let request = store.add(object);
+    request.onsuccess = () => resolve(object);
+    request.onerror = () => reject(request.error);
+  });
 }
 
 function get(objectStore, object) {
-    return new Promise((resolve, reject) => {
-        const request = objectStore.get(object._id);
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(request.error);
-    });
+  return new Promise((resolve, reject) => {
+    const request = objectStore.get(object._id);
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
 }
 
 function put(objectStore, object) {
-    return new Promise((resolve, reject) => {
-        const store = objectStore.objectStore || objectStore
-        let request = store.put(object);
+  return new Promise((resolve, reject) => {
+    const store = objectStore.objectStore || objectStore;
+    let request = store.put(object);
 
-        request.onsuccess = () => resolve(object);
-        request.onerror = () => reject(request.error);
-    });
+    request.onsuccess = () => resolve(object);
+    request.onerror = () => reject(request.error);
+  });
 }
 
 function deleteObject(objectStore, object) {
-    return new Promise((resolve, reject) => {
-        const request = objectStore.delete(object._id);
-        request.onsuccess = () => resolve(object);
-        request.onerror = () => reject(request.error);
-    });
+  return new Promise((resolve, reject) => {
+    const request = objectStore.delete(object._id);
+    request.onsuccess = () => resolve(object);
+    request.onerror = () => reject(request.error);
+  });
 }
 
 function cursorUpdate(cursor, update) {
-    return new Promise((resolve, reject) => {
-        const request = cursor.update(update)
-        request.onsuccess = () => resolve(request.source.value);
-        request.onerror = () => reject(request.error);
-    });
+  return new Promise((resolve, reject) => {
+    const request = cursor.update(update);
+    request.onsuccess = () => resolve(request.source.value);
+    request.onerror = () => reject(request.error);
+  });
 }
 
-
 function filter(objectStore, data, object, result) {
-    let isMatch = true;
-    let filter = data.$filter || object.$filter
-    if (filter) {
-        if (filter.query)
-            isMatch = queryData(result, filter.query);
-        if (isMatch && filter.search)
-            isMatch = searchData(result, filter.search);
-    }
-
-    return isMatch
+  let isMatch = true;
+  let filter = data.$filter || object.$filter;
+  if (filter) {
+    if (filter.query) isMatch = queryData(result, filter.query);
+    if (isMatch && filter.search) isMatch = searchData(result, filter.search);
+  }
+
+  return isMatch;
 }
 
 function getGlobalOperators(data, object = {}) {
-    for (let operator of Object.keys(data)) {
-        if (!operator.startsWith('$'))
-            return
-        for (let key of Object.keys(data[operator]))
-            object[operator + '.' + key] = data[operator][key]
-    }
+  for (let operator of Object.keys(data)) {
+    if (!operator.startsWith("$")) return;
+    for (let key of Object.keys(data[operator]))
+      object[operator + "." + key] = data[operator][key];
+  }
 
-    return object
+  return object;
 }
 
 function createData(data, newData, 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) {
-        if (data.$filter.sort)
-            data[type] = sortData(data[type], data.$filter.sort)
-
-        data.$filter.startingIndex = data.$filter.index
-        data.$filter.index += data[type].length
-    }
-
-    return data
+  // 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) {
+    if (data.$filter.sort) data[type] = sortData(data[type], data.$filter.sort);
+
+    data.$filter.startingIndex = data.$filter.index;
+    data.$filter.index += data[type].length;
+  }
+
+  return data;
 }
 
 function errorHandler(data, error, database, array) {
-    if (typeof error == 'object')
-        error['storage'] = 'indexeddb'
-    else
-        error = { storage: 'indexeddb', message: error }
-
-    if (database)
-        error['database'] = database
-    if (array)
-        error['array'] = array
-    if (data.error)
-        data.error.push(error)
-    else
-        data.error = [error]
+  console.error(error, data);
+  if (typeof error == "object") error["storage"] = "indexeddb";
+  else error = { storage: "indexeddb", message: error };
+
+  if (database) error["database"] = database;
+  if (array) error["array"] = array;
+  if (data.error) data.error.push(error);
+  else data.error = [error];
 }
 
 init();
 
-export default { send, ObjectId }
+export default { send, ObjectId };