@cocreate/mongodb 1.10.6 → 1.12.0

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+# [1.12.0](https://github.com/CoCreate-app/CoCreate-mongodb/compare/v1.11.0...v1.12.0) (2023-11-09)
+
+
+### Bug Fixes
+
+* $storage, $database, $array are arrays ([9cda13a](https://github.com/CoCreate-app/CoCreate-mongodb/commit/9cda13ad88eff2639da6b1c5a60dc901a54d0518))
+* meta name typo ([c7c8e1d](https://github.com/CoCreate-app/CoCreate-mongodb/commit/c7c8e1d7182f5992a5a1567e2ff7edf678cefbde))
+* update date queries ([3f8103d](https://github.com/CoCreate-app/CoCreate-mongodb/commit/3f8103db89f0037f566e930928742a20825e24cd))
+* update method names ([936254d](https://github.com/CoCreate-app/CoCreate-mongodb/commit/936254d850536e55daaaf2d7862930a3068e8aee))
+
+
+### Features
+
+* merge data[types] with same _id for type objects and name for all other types ([1da51a8](https://github.com/CoCreate-app/CoCreate-mongodb/commit/1da51a8c0600ecbe84af41fcc5c77f1949d36c60))
+
+# [1.11.0](https://github.com/CoCreate-app/CoCreate-mongodb/compare/v1.10.6...v1.11.0) (2023-11-03)
+
+
+### Bug Fixes
+
+* favicon.ico path ([5e54a37](https://github.com/CoCreate-app/CoCreate-mongodb/commit/5e54a371dcbebc7364d401570c3f0cbeb3f0db31))
+* update dependencies to the lates versions ([2a4dc62](https://github.com/CoCreate-app/CoCreate-mongodb/commit/2a4dc6263067c3c1cc4571d623aa8530a83708d1))
+* update method to use object.update etc ([1e9e7b8](https://github.com/CoCreate-app/CoCreate-mongodb/commit/1e9e7b8e81d7512ec546cdbcbc381851477f8271))
+
+
+### Features
+
+* morph data[type] so the object can be synced across multiple storage, database, arra ([8d29c0a](https://github.com/CoCreate-app/CoCreate-mongodb/commit/8d29c0a7cc160654e04e0e6266f82906e772f57f))
+* read.object will compare modified.on and update db ([b8b2c74](https://github.com/CoCreate-app/CoCreate-mongodb/commit/b8b2c74e2abbf568eda14c1328961781395d7c5c))
+
 ## [1.10.6](https://github.com/CoCreate-app/CoCreate-mongodb/compare/v1.10.5...v1.10.6) (2023-10-25)
 
 

package/demo/index.html

@@ -6,9 +6,9 @@
         <meta name="viewport" content="width=device-width, initial-scale=1" />
         <link
             rel="icon"
-            href="https://cdn.cocreate.app/favicon.ico"
-            type="image/ico"
-            sizes="16x16" />
+            type="image/png"
+            sizes="32x32"
+            href="../assets/favicon.ico" />
         <title>mongodb | CoCreateJS</title>
     </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/mongodb",
-  "version": "1.10.6",
+  "version": "1.12.0",
   "description": "A simple mongodb component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "mongodb",
@@ -45,7 +45,7 @@
   },
   "main": "./src/index.js",
   "dependencies": {
-    "@cocreate/utils": "^1.26.1",
+    "@cocreate/utils": "^1.26.2",
     "mongodb": "^4.12.1"
   }
 }

package/src/index.js

@@ -1,40 +1,41 @@
 const { MongoClient, ObjectId } = require('mongodb');
 const { dotNotationToObject, queryData, searchData, sortData, isValidDate } = require('@cocreate/utils')
 const clients = new Map()
-
+const organizations = {}
 
 async function dbClient(data) {
     if (data.storageUrl) {
-        let client = clients.get(data.storageUrl)
-        if (!client && !clients.has(data.storageUrl)) {
-            try {
-                clients.set(data.storageUrl, client)
-                client = await MongoClient.connect(data.storageUrl, { useNewUrlParser: true, useUnifiedTopology: true });
-                clients.set(data.storageUrl, client)
-            } catch (error) {
-                console.error(`${data.organization_id}: storageName ${data.storageName} failed to connect to mongodb`)
-                errorHandler(data, error)
-                return { status: false }
-            }
+        if (!organizations[data.organization_id])
+            organizations[data.organization_id] = {}
+        try {
+            if (!organizations[data.organization_id][data.storageUrl])
+                organizations[data.organization_id][data.storageUrl] = MongoClient.connect(data.storageUrl, { useNewUrlParser: true, useUnifiedTopology: true })
+
+            organizations[data.organization_id][data.storageUrl] = await organizations[data.organization_id][data.storageUrl]
+            return organizations[data.organization_id][data.storageUrl]
+
+        } catch (error) {
+            console.error(`${data.organization_id}: storageName ${data.storageName} failed to connect to mongodb`)
+            errorHandler(data, error)
+            return { status: false }
         }
-        return client
     }
+
+    errorHandler(data, 'missing StorageUrl')
     return
 }
 
 function send(data) {
-    let [method, type] = data.method.split('.')
-    // let action = data.method.replace(/\.([a-z])/g, (_, match) => match.toUpperCase());
-
+    let [type, method] = data.method.split('.')
     if (type === 'database')
-        return database(method + type.charAt(0).toUpperCase() + type.slice(1), data)
+        return database(method, data)
     if (type === 'array')
-        return array(method + type.charAt(0).toUpperCase() + type.slice(1), data)
+        return array(method, data)
     if (type === 'object')
-        return object(method + type.charAt(0).toUpperCase() + type.slice(1), data)
+        return object(method, data)
 }
 
-function database(action, data) {
+function database(method, data) {
     return new Promise(async (resolve, reject) => {
         let type = 'database'
         let databaseArray = []
@@ -45,7 +46,7 @@ function database(action, data) {
             const client = await dbClient(data)
             if (!client || client.status === false)
                 return data
-            if (action == 'readDatabase') {
+            if (method == 'read') {
                 const db = client.db().admin();
                 // TODO: support if a database name is defined then return the database details and stats
                 // else apply filter and return dbs for which each should have stats and details
@@ -70,7 +71,7 @@ function database(action, data) {
                     resolve(createData(data, databaseArray, type))
                 })
             }
-            if (action == 'deleteDatabase') {
+            if (method == 'delete') {
                 const db = client.db(data.database);
                 db.dropDatabase().then(restult => {
                     dataTransferedIn += getBytes(restult)
@@ -79,7 +80,7 @@ function database(action, data) {
             }
         } catch (error) {
             errorHandler(data, error)
-            console.log(action, 'error', error);
+            console.log(method, 'error', error);
             resolve(data);
         }
 
@@ -88,7 +89,7 @@ function database(action, data) {
     });
 }
 
-function array(action, data) {
+function array(method, data) {
     return new Promise(async (resolve, reject) => {
         let type = 'array'
         let arrayArray = [];
@@ -111,7 +112,7 @@ function array(action, data) {
             for (let database of databases) {
                 const db = client.db(database);
 
-                if (action == 'readCollection') {
+                if (method == 'read') {
 
                     let { query, sort } = await createFilter(data);
 
@@ -141,7 +142,7 @@ function array(action, data) {
                 } else {
                     let arrays
                     let value
-                    if (action == 'updateCollection')
+                    if (method == 'update')
                         arrays = Object.entries(data.array)
                     else
                         arrays = data.array;
@@ -152,7 +153,7 @@ function array(action, data) {
                     let arraysLength = arrays.length
                     for (let array of arrays) {
 
-                        if (action == 'createCollection') {
+                        if (method == 'create') {
                             dataTransferedOut += getBytes(array)
                             db.createCollection(array, function (error, result) {
                                 if (error)
@@ -173,13 +174,13 @@ function array(action, data) {
                                 }
                             })
                         } else {
-                            if (action == 'updateCollection') {
+                            if (method == 'update') {
                                 [array, value] = array
                             }
 
                             const arrayObj = db.collection(array);
 
-                            if (action == 'updateCollection') {
+                            if (method == 'update') {
                                 dataTransferedOut += getBytes(result)
                                 arrayObj.rename(value, function (error, result) {
                                     if (error)
@@ -201,7 +202,7 @@ function array(action, data) {
                                 })
                             }
 
-                            if (action == 'deleteCollection') {
+                            if (method == 'delete') {
                                 arrayObj.drop(function (error, result) {
                                     if (error)
                                         errorHandler(data, error, database, array)
@@ -231,7 +232,7 @@ function array(action, data) {
 
         } catch (error) {
             errorHandler(data, error)
-            console.log(action, 'error', error);
+            console.log(method, 'error', error);
             resolve(data);
         }
     }, (error) => {
@@ -239,10 +240,11 @@ function array(action, data) {
     });
 }
 
-function object(action, data) {
+function object(method, data) {
     return new Promise(async (resolve, reject) => {
         try {
             const client = await dbClient(data)
+
             if (!client || client.status === false)
                 return data
 
@@ -251,13 +253,8 @@ function object(action, data) {
             let type = 'object'
             let documents = [];
 
-            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 (!Array.isArray(databases))
@@ -281,22 +278,29 @@ function object(action, data) {
                     let isFilter
                     if (data.$filter)
                         isFilter = true
-                    if (isFilter && !data[type].length)
-                        data[type] = [{}]
+                    if ((isFilter && !data[type].length) || data.isFilter)
+                        data[type].splice(0, 0, { isFilter: 'isEmptyObjectFilter' });
 
                     let filter = await createFilter(data, arrayObj);
 
                     let projections = {}, projection = {}, update = {}, options = {}
 
-                    if (action === 'updateObject')
+                    if (method === 'update')
                         createUpdate(update, options, data, true)
 
                     for (let i = 0; i < data[type].length; i++) {
+                        let $storage = data[type][i].$storage || []
+                        let $database = data[type][i].$database || []
+                        let $array = data[type][i].$array || []
+                        $storage.push(data.storageName)
+                        $database.push(database)
+                        $array.push(array)
+
                         delete data[type][i].$storage
                         delete data[type][i].$database
                         delete data[type][i].$array
 
-                        if (action !== 'createObject' && data[type][i].$filter) {
+                        if (method !== 'create' && data[type][i].$filter) {
                             isFilter = true
                             reference['$filter'] = data[type][i].$filter
                             filter = await createFilter({ $filter: data[type][i].$filter }, arrayObj)
@@ -304,25 +308,29 @@ function object(action, data) {
 
                         let { query, sort, index, limit } = filter
 
-                        if (action === 'createObject') {
+                        if (method === 'create') {
                             data[type][i] = replaceArray(data[type][i])
                             data[type][i] = dotNotationToObject(data[type][i])
                             data[type][i]['organization_id'] = data['organization_id'];
-                            data[type][i]['created'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-                        } else if (action === 'readObject') {
+                            data[type][i]['created'] = { on: new Date(data.timeStamp), by: data.user_id || data.clientId }
+                        } else if (method === 'read') {
                             projection = createProjection(data[type][i])
-                        } else if (action === 'updateObject') {
-                            data[type][i].modified = { on: data.timeStamp, by: data.user_id || data.clientId }
+                        } else if (method === 'update') {
+                            if (!data[type][i].modified)
+                                data[type][i].modified = { on: new Date(data.timeStamp), by: data.user_id || data.clientId }
+                            else
+                                data[type][i].modified.on = new Date(data[type][i].modified.on)
+
                             data[type][i].organization_id = data.organization_id
                             createUpdate(update, options, data[type][i])
                         }
 
-                        if (data[type][i]._id || action === 'createObject') {
-                            if (action !== 'createObject') {
+                        if (data[type][i]._id || method === 'create') {
+                            if (method !== 'create') {
                                 try {
                                     query._id = new ObjectId(data[type][i]._id);
                                 } catch (error) {
-                                    if (action === 'updateObject' && options.upsert) {
+                                    if (method === 'update' && options.upsert) {
                                         data[type][i]._id = ObjectId()
                                         query._id = data[type][i]._id;
                                     } else {
@@ -337,7 +345,7 @@ function object(action, data) {
                                 dataTransferedOut += getBytes({ query, update, projection, options })
 
                                 let result
-                                if (action === 'createObject') {
+                                if (method === 'create') {
                                     if (data[type][i]._id) {
                                         try {
                                             data[type][i]._id = new ObjectId(data[type][i]._id);
@@ -348,21 +356,38 @@ function object(action, data) {
                                     result = await arrayObj.insertOne(data[type][i]);
                                     // TODO: type error occuring when pushing the item pushes but throws an error
                                     data[type][i]._id = result.insertedId.toString()
-                                    documents.push({ ...data[type][i], ...reference })
-                                } else if (action === 'readObject') {
+                                    // documents.push({ ...data[type][i], ...reference })
+                                } else if (method === 'read') {
                                     result = await arrayObj.findOne(query, projection);
                                     result._id = result._id.toString()
-                                    documents.push({ ...result, ...reference })
-                                } else if (action === 'updateObject') {
+
+                                    if (data[type][i].$storage && data[type][i].modified && data[type][i].modified.on) {
+                                        if (!result) {
+                                            result = await arrayObj.insertOne(data[type][i]);
+                                            data[type][i]._id = result.insertedId.toString()
+                                        } else if (result && new Date(data[type][i].modified.on) > new Date(result.modified.on)) {
+                                            data[type][i] = { ...result, ...data[type][i] }
+                                            createUpdate(update, options, data[type][i])
+                                            result = await arrayObj.updateOne(query, update, options);
+                                        } else
+                                            data[type][i] = { ...data[type][i], ...result }
+                                    } else
+                                        data[type][i] = { ...data[type][i], ...result }
+                                } else if (method === 'update') {
                                     result = await arrayObj.updateOne(query, update, options);
 
                                     // TODO: handle upsert false and id does not exist
                                     data[type][i]._id = query._id.toString()
-                                    documents.push({ ...data[type][i], ...reference })
-                                } else if (action === 'deleteObject') {
+                                    // documents.push({ ...data[type][i], ...reference })
+                                } else if (method === 'delete') {
                                     result = await arrayObj.deleteOne(query);
-                                    documents.push({ ...reference, _id: data[type][i]._id })
+                                    // documents.push({ ...reference, _id: data[type][i]._id })
                                 }
+
+                                data[type][i].$storage = $storage
+                                data[type][i].$database = $database
+                                data[type][i].$array = $array
+
                                 dataTransferedIn += getBytes(result)
 
                             } catch (error) {
@@ -370,16 +395,14 @@ function object(action, data) {
                             }
                         } else if (isFilter) {
                             try {
-                                if (action === 'readObject')
+                                if (method === 'read')
                                     projection = { ...projections, ...projection }
 
-                                delete query._id
-
                                 dataTransferedOut += getBytes({ query, projection, sort, index, limit })
-                                let document = ''
 
+                                let document = ''
                                 const cursor = arrayObj.find(query, projection).sort(sort).skip(index).limit(limit);
-                                if (!(await cursor.hasNext()) && action === 'updateObject' && data.upsert)
+                                if (!(await cursor.hasNext()) && method === 'update' && data.upsert)
                                     document = { _id: ObjectId(data[type][i]._id) }
 
                                 while (await cursor.hasNext() || document) {
@@ -394,13 +417,28 @@ function object(action, data) {
                                             continue;
                                     }
 
-                                    if (action === 'readObject') {
-                                        documents.push({ ...document, ...reference, _id: document._id.toString() })
+                                    if (method === 'read') {
+                                        document._id = document._id.toString()
+                                        let object = data[type].find(obj => obj._id && obj._id.toString() === document._id.toString())
+                                        if (object) {
+                                            if (object.$storage && object.modified && object.modified.on) {
+                                                if (document && new Date(object.modified.on) > new Date(document.modified.on)) {
+                                                    object = { ...document, ...object }
+                                                    createUpdate(update, options, object)
+                                                    document = await arrayObj.updateOne(query, update, options);
+                                                    dataTransferedIn += getBytes(document)
+                                                } else
+                                                    documents.push({ ...document, ...reference })
+                                            } else
+                                                documents.push({ ...document, ...reference })
+
+                                        } else
+                                            documents.push({ ...document, ...reference })
                                     } else {
                                         dataTransferedOut += getBytes({ _id: document._id, update, options })
 
                                         let result
-                                        if (action === 'updateObject') {
+                                        if (method === 'update') {
                                             if (options.returnNewDocument) {
                                                 let object = await arrayObj.findOneAndUpdate({ _id: document._id }, update, options);
                                                 for (let key of Object.keys(object)) {
@@ -415,13 +453,13 @@ function object(action, data) {
                                             } else
                                                 result = await arrayObj.updateOne({ _id: document._id }, update, options);
                                             // TODO: if update.$push or update.$each read document with projection to get index and update the keys [] to include index
-                                        } else if (action === 'deleteObject') {
+                                        } else if (method === 'delete') {
                                             result = await arrayObj.deleteOne({ _id: document._id });
                                         }
 
                                         dataTransferedIn += getBytes(result)
                                         documents.push({ ...data[type][i], ...reference, _id: document._id.toString() })
-                                        data[type].push({ ...data[type][i], ...reference, _id: document._id.toString() })
+                                        // data[type].push({ ...data[type][i], ...reference, _id: document._id.toString() })
 
                                     }
                                     document = ''
@@ -433,7 +471,7 @@ function object(action, data) {
                         }
                     }
 
-                    // if (action === 'createObject') {
+                    // if (method === 'create') {
                     //     try {
                     //         dataTransferedOut += getBytes(data[type])
                     //         const result = await arrayObj.insertMany(data[type]);
@@ -449,13 +487,12 @@ function object(action, data) {
 
                 }
             }
-
             data = createData(data, documents, type, dataTransferedIn, dataTransferedOut)
             resolve(data)
 
         } catch (error) {
             errorHandler(data, error)
-            console.log(action, 'error', error);
+            console.log(method, 'error', error);
             resolve(data);
         }
     }, (error) => {
@@ -473,7 +510,9 @@ function createUpdate(update, options, data, isGlobal) {
     Object.keys(data).forEach(key => {
         if (isGlobal && !key.startsWith('$') || key === '_id')
             return
-        data[key] = isValidDate(data[key])
+
+        if (isValidDate(data[key]))
+            data[key] = new Date(data[key])
 
         let operator
         if (key.endsWith(']')) {
@@ -622,7 +661,8 @@ function createQuery(queries) {
                 continue
         }
 
-        item.value = isValidDate(item.value)
+        if (isValidDate(item.value))
+            item.value = new Date(item.value)
 
         let key = item.key;
         if (!query[key]) {
@@ -732,15 +772,31 @@ function createData(data, array, type, dataTransferedIn, dataTransferedOut) {
         });
     }
 
-    if (!data.request)
-        data.request = data[type] || {}
-
-    data[type] = array
+    if (data[type] && data[type][0] && data[type][0].isFilter === 'isEmptyObjectFilter') {
+        data[type].shift()
+        data.isFilter = true
+    }
 
-    if (data.returnLog) {
-        if (!data.log)
-            data.log = []
-        data.log.push(...data[type])
+    // if (!data.request)
+    //     data.request = data[type] || {}
+
+    let key = '_id'
+    if (type !== 'object')
+        key = 'name'
+    for (let i = 0; i < array.length; i++) {
+        const matchIndex = data[type].findIndex((item) => item[key] === array[i][key]);
+        if (matchIndex !== -1) {
+            data[type][matchIndex].$storage.push(array[i].$storage)
+            delete array[i].$storage
+            data[type][matchIndex].$database.push(array[i].$database)
+            delete array[i].$database
+            data[type][matchIndex].$array.push(array[i].$array)
+            delete array[i].$array
+
+            // TODO: compare dates and merge and and updates to keep all synced and up to date
+            data[type][matchIndex] = { ...data[type][matchIndex], ...array[i] };
+        } else
+            data[type].push(array[i])
     }
 
     return data