@cocreate/mongodb 1.8.0 → 1.9.1

package/src/index.js

@@ -20,52 +20,44 @@ async function dbClient(data) {
     return
 }
 
-async function databaseStats(data) {
-    const client = await dbClient(data)
-    if (!client) return
-    const db = client.db(data.organization_id)
-    const stats = await db.stats()
-    stats.storage = data.storageName
-    if (!data.stats)
-        data.stats = [stats]
-    else
-        data.stats.push(stats)
-    return data
-}
-
-function createDatabase(data) {
-    return database('createDatabase', data)
-}
-
-function readDatabase(data) {
-    return database('readDatabase', data)
-}
-
-function updateDatabase(data) {
-    return database('updateDatabase', data)
-}
-
-function deleteDatabase(data) {
-    return database('deleteDatabase', data)
+function send(data) {
+    let [method, type] = data.method.split('.')
+    // let action = data.method.replace(/\.([a-z])/g, (_, match) => match.toUpperCase());
+
+    if (type === 'database')
+        return database(method + type.charAt(0).toUpperCase() + type.slice(1), data)
+    if (type === 'array')
+        return array(method + type.charAt(0).toUpperCase() + type.slice(1), data)
+    if (type === 'object')
+        return object(method + type.charAt(0).toUpperCase() + type.slice(1), data)
 }
 
 function database(action, data) {
     return new Promise(async (resolve, reject) => {
         let type = 'database'
         let databaseArray = []
+        let dataTransferedIn = 0
+        let dataTransferedOut = 0
 
         try {
             const client = await dbClient(data)
             if (!client) return
             if (action == 'readDatabase') {
                 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
+                // if (data.database) {
+                //     const db = client.db(data.organization_id)
+                //     const stats = await db.stats()
+                // }
 
                 // List all the available databases
                 db.listDatabases(function (err, dbs) {
+                    dataTransferedIn += getBytes(dbs)
 
                     for (let database of dbs.databases) {
-                        if (data.filter && data.filter.query) {
-                            let isFilter = queryData(database, data.filter.query)
+                        if (data.$filter && data.$filter.query) {
+                            let isFilter = queryData(database, data.$filter.query)
                             if (isFilter)
                                 databaseArray.push({ database, storage: data.storageName })
                         } else
@@ -77,8 +69,9 @@ function database(action, data) {
             }
             if (action == 'deleteDatabase') {
                 const db = client.db(data.database);
-                db.dropDatabase().then(response => {
-                    resolve(response)
+                db.dropDatabase().then(restult => {
+                    dataTransferedIn += getBytes(restult)
+                    resolve(restult)
                 })
             }
         } catch (error) {
@@ -92,27 +85,12 @@ function database(action, data) {
     });
 }
 
-
-function createCollection(data) {
-    return array('createCollection', data)
-}
-
-function readCollection(data) {
-    return array('readCollection', data)
-}
-
-function updateCollection(data) {
-    return array('updateCollection', data)
-}
-
-function deleteCollection(data) {
-    return array('deleteCollection', data)
-}
-
 function array(action, data) {
     return new Promise(async (resolve, reject) => {
         let type = 'array'
         let arrayArray = [];
+        let dataTransferedIn = 0
+        let dataTransferedOut = 0
 
         try {
             const client = await dbClient(data)
@@ -131,16 +109,18 @@ function array(action, data) {
 
                 if (action == 'readCollection') {
 
-                    let { query, sort } = await getFilters(data);
+                    let { query, sort } = await createFilter(data);
 
                     db.listCollections().toArray(function (error, result) {
                         if (error)
                             errorHandler(data, error, database)
 
                         if (result) {
+                            dataTransferedIn += getBytes(result)
+
                             for (let res of result) {
-                                if (data.filter && data.filter.query) {
-                                    let isFilter = queryData(res, data.filter.query)
+                                if (data.$filter && data.$filter.query) {
+                                    let isFilter = queryData(res, data.$filter.query)
                                     if (isFilter)
                                         arrayArray.push({ name: res.name, database, storage: data.storageName })
                                 } else
@@ -150,7 +130,7 @@ function array(action, data) {
 
                         databasesLength -= 1
                         if (!databasesLength) {
-                            data = createData(data, arrayArray, type)
+                            data = createData(data, arrayArray, type, dataTransferedIn, dataTransferedOut)
                             resolve(data)
                         }
                     })
@@ -169,19 +149,22 @@ function array(action, data) {
                     for (let array of arrays) {
 
                         if (action == 'createCollection') {
+                            dataTransferedOut += getBytes(array)
                             db.createCollection(array, function (error, result) {
                                 if (error)
                                     errorHandler(data, error, database, array)
 
-                                if (result)
+                                if (result) {
+                                    dataTransferedIn += getBytes(result)
                                     arrayArray.push({ name: array, database, storage: data.storageName })
+                                }
 
                                 arraysLength -= 1
                                 if (!arraysLength)
                                     databasesLength -= 1
 
                                 if (!databasesLength && !arraysLength) {
-                                    data = createData(data, arrayArray, type)
+                                    data = createData(data, arrayArray, type, dataTransferedIn, dataTransferedOut)
                                     resolve(data)
                                 }
                             })
@@ -193,19 +176,21 @@ function array(action, data) {
                             const arrayObj = db.collection(array);
 
                             if (action == 'updateCollection') {
+                                dataTransferedOut += getBytes(result)
                                 arrayObj.rename(value, function (error, result) {
                                     if (error)
                                         errorHandler(data, error, database, array)
 
-                                    if (result)
+                                    if (result) {
+                                        dataTransferedIn += getBytes(result)
                                         arrayArray.push({ name: value, oldName: array, database, storage: data.storageName })
-
+                                    }
                                     arraysLength -= 1
                                     if (!arraysLength)
                                         databasesLength -= 1
 
                                     if (!databasesLength && !arraysLength) {
-                                        data = createData(data, arrayArray, type)
+                                        data = createData(data, arrayArray, type, dataTransferedIn, dataTransferedOut)
                                         resolve(data)
                                     }
 
@@ -217,15 +202,17 @@ function array(action, data) {
                                     if (error)
                                         errorHandler(data, error, database, array)
 
-                                    if (result)
+                                    if (result) {
+                                        dataTransferedOut += getBytes(result)
                                         arrayArray.push({ name: array, database, storage: data.storageName })
+                                    }
 
                                     arraysLength -= 1
                                     if (!arraysLength)
                                         databasesLength -= 1
 
                                     if (!databasesLength && !arraysLength) {
-                                        data = createData(data, arrayArray, type)
+                                        data = createData(data, arrayArray, type, dataTransferedIn, dataTransferedOut)
                                         resolve(data)
                                     }
 
@@ -248,29 +235,13 @@ function array(action, data) {
     });
 }
 
-
-function createObject(data) {
-    return object('createObject', data)
-}
-
-function readObject(data) {
-    return object('readObject', data)
-}
-
-function updateObject(data) {
-    return object('updateObject', data)
-}
-
-function deleteObject(data) {
-    return object('deleteObject', data)
-}
-
 function object(action, data) {
     return new Promise(async (resolve, reject) => {
         try {
             const client = await dbClient(data)
             if (!client) return
-
+            let dataTransferedIn = 0
+            let dataTransferedOut = 0
             let type = 'object'
             let documents = [];
 
@@ -284,238 +255,149 @@ function object(action, data) {
             if (!Array.isArray(databases))
                 databases = [databases]
 
-            let databasesLength = databases.length
             for (let database of databases) {
                 let arrays = data.array;
                 if (!Array.isArray(arrays))
                     arrays = [arrays]
 
-                let arraysLength = arrays.length
                 for (let array of arrays) {
                     const db = client.db(database);
                     const arrayObj = db.collection(array);
+                    const reference = { $storage: data.storageName, $database: database, $array: array }
 
                     if (data[type] && !Array.isArray(data[type]))
                         data[type] = [data[type]]
 
-                    if (action == 'createObject') {
-                        for (let i = 0; i < data[type].length; i++) {
-                            data[type][i] = replaceArray(data[type][i])
-                            data[type][i] = dotNotationToObject(data[type][i])
-                            data[type][i]['organization_id'] = data['organization_id'];
+                    let isFilter
+                    if (data.$filter && data.$filter.query)
+                        isFilter = true
 
-                            if (!data[type][i]._id)
-                                data[type][i]._id = ObjectId()
-                            else
-                                data[type][i]._id = ObjectId(data[type][i]._id)
-                            data[type][i]['created'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-                        }
+                    let filter = await createFilter(data, arrayObj);
 
-                        arrayObj.insertMany(data[type], function (error, result) {
-                            if (error)
-                                errorHandler(data, error, database, array)
+                    let projections = {}, projection = {}, update = {}, options = {}
 
-                            for (let i = 0; i < data[type].length; i++)
-                                documents.push({ storage: data.storageName, database, array, ...data[type][i] })
+                    if (isFilter && (!data[type] || !data[type].length))
+                        data[type] = [{}]
 
-                            arraysLength -= 1
-                            if (!arraysLength)
-                                databasesLength -= 1
+                    if (action === 'updateObject')
+                        createUpdate(update, options, data, true)
 
-                            if (!databasesLength && !arraysLength) {
-                                data = createData(data, documents, type)
-                                resolve(data)
-                            }
-                        });
-                    } else {
-                        let isFilter
-                        if (data.filter && data.filter.query)
+                    for (let i = 0; i < data[type].length; i++) {
+                        if (action !== 'createObject' && data[type][i].$filter) {
                             isFilter = true
+                            reference['$filter'] = data[type][i].$filter
+                            filter = await createFilter({ $filter: data[type][i].$filter }, arrayObj)
+                        }
 
-                        let { query, sort, index, limit } = await getFilters(data, arrayObj);
-
-                        if (action == 'readObject') {
-                            if (data[type]) {
-                                let _ids = []
-                                for (let i = 0; i < data[type].length; i++) {
-                                    data[type][i] = replaceArray(data[type][i])
-                                    if (data[type][i]._id) {
-                                        _ids.push(ObjectId(data[type][i]._id))
-                                    }
-                                }
-
-                                if (_ids.length == 1)
-                                    query['_id'] = _ids[0]
-                                else if (_ids.length > 0)
-                                    query['_id'] = { $in: _ids }
+                        let { query, sort, index, limit } = filter
 
-                            }
+                        if (action === 'createObject') {
+                            data[type][i] = replaceArray(data[type][i])
+                            data[type][i] = dotNotationToObject(data[type][i])
+                            data[type][i]._id = ObjectId(data[type][i]._id)
+                            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') {
+                            projection = createProjection(data[type][i])
+                        } else if (action === 'updateObject') {
+                            data[type][i].modified = { on: data.timeStamp, by: data.user_id || data.clientId }
+                            data[type][i].organization_id = data.organization_id
+                            createUpdate(update, options, data[type][i])
+                        }
 
+                        if (data[type][i]._id) {
                             try {
-                                const cursor = arrayObj.find(query).sort(sort).skip(index).limit(limit);
-                                while (await cursor.hasNext()) {
-                                    const document = await cursor.next();
-
-                                    if (data.filter && data.filter.search) {
-                                        let isMatch = searchData(document, data.filter.search)
-                                        if (!isMatch)
-                                            continue;
-                                    }
-
-                                    document.storage = 'mongodb'
-                                    document.database = database
-                                    document.array = array
-                                    document._id = document._id.toString()
-
-                                    if (data.returnObject == false) {
-                                        let tempDoc = {};
-                                        let docs = new Map(data[type].map((obj) => [obj._id, obj]));
-                                        let doc1 = docs.get(document._id)
-                                        if (doc1) {
-                                            tempDoc._id = tempDoc
-                                            for (let key of Object.keys(doc1)) {
-                                                tempDoc[key] = document[key]
-                                            }
-                                            document = tempDoc
-                                        }
-                                    }
+                                if (action !== 'createObject') {
+                                    query._id = ObjectId(data[type][i]._id)
+                                }
 
-                                    documents.push(document)
+                                dataTransferedOut += getBytes({ query, update, projection, options })
+
+                                let result
+                                if (action === 'createObject') {
+                                    let _id = data[type][i]._id.toString()
+                                    // TODO: type error occuring when pushing the item pushes but throws an error
+                                    documents.push({ ...data[type][i], ...reference, _id })
+                                } else if (action === 'readObject') {
+                                    result = await arrayObj.findOne(query, projection);
+                                    result._id = result._id.toString()
+                                    documents.push({ ...result, ...reference })
+                                } else if (action === 'updateObject') {
+                                    result = await arrayObj.updateOne(query, update, options);
+                                    documents.push({ ...data[type][i], ...reference })
+                                } else if (action === 'deleteObject') {
+                                    result = await arrayObj.deleteOne(query);
+                                    documents.push({ ...reference, _id: data[type][i]._id })
                                 }
+                                dataTransferedIn += getBytes(result)
+
                             } catch (error) {
                                 errorHandler(data, error, database, array)
                             }
+                        } else if (isFilter) {
+                            try {
+                                if (action === 'readObject')
+                                    projection = { ...projections, ...projection }
 
-                            arraysLength -= 1
-                            if (!arraysLength)
-                                databasesLength -= 1
+                                delete query._id
 
-                            if (!databasesLength && !arraysLength) {
-                                data = createData(data, documents, type)
-                                resolve(data)
-                            }
-                        } else if (action == 'updateObject') {
+                                dataTransferedOut += getBytes({ query, projection, sort, index, limit })
+                                let document = ''
 
-                            if (!data[type].length) {
-                                arraysLength -= 1
+                                const cursor = arrayObj.find(query, projection).sort(sort).skip(index).limit(limit);
+                                if (!(await cursor.hasNext()) && action === 'updateObject' && data.upsert)
+                                    document = { _id: ObjectId(data[type][i]._id) }
+                                while (await cursor.hasNext() || document) {
+                                    if (!document)
+                                        document = await cursor.next();
 
-                                if (!arraysLength)
-                                    databasesLength -= 1
+                                    dataTransferedIn += getBytes(document)
 
-                                if (!databasesLength && !arraysLength) {
-                                    data = createData(data, documents, type)
-                                    resolve(data)
-                                }
-                            }
-
-                            let docsLength = data[type].length
-                            for (let i = 0; i < data[type].length; i++) {
-                                if (data[type][i]._id)
-                                    query['_id'] = ObjectId(data[type][i]._id)
-
-                                data[type][i] = replaceArray(data[type][i])
-                                let { update, projection } = createUpdate(data, type, i)
-
-                                if (query['_id']) {
-                                    arrayObj.updateOne(query, update, {
-                                        upsert: data.upsert,
-                                        projection
-                                    }).then((result) => {
-                                        documents.push({ _id: query['_id'].toString(), storage: data.storageName, database, array, ...update['$set'] })
-                                    }).catch((error) => {
-                                        errorHandler(data, error, database, array)
-                                        console.log(action, 'error', error);
-                                    }).finally(() => {
-                                        docsLength -= 1
-                                        if (!docsLength)
-                                            arraysLength -= 1
-
-                                        if (!arraysLength)
-                                            databasesLength -= 1
-
-                                        if (!databasesLength && !arraysLength) {
-                                            data = createData(data, documents, type)
-                                            resolve(data)
-                                        }
-                                    })
-                                } else if (update && isFilter) {
-                                    const cursor = arrayObj.find(query).sort(sort).skip(index).limit(limit);
-                                    while (await cursor.hasNext()) {
-                                        const document = await cursor.next();
-
-                                        if (data.filter && data.filter.search) {
-                                            let isMatch = searchData(document, data.filter.search)
-                                            if (!isMatch)
-                                                continue;
-                                        }
-
-                                        arrayObj.updateOne({ _id: document._id }, update, {
-                                            upsert: data.upsert,
-                                            projection
-                                        }).then((result) => {
-                                            if (data.returnObject != false)
-                                                documents.push({ _id: document._id, storage: data.storageName, database, array, ...update['$set'] })
-                                        }).catch((error) => {
-                                            errorHandler(data, error, database, array)
-                                            console.log(action, 'error', error);
-                                        })
-                                    }
-                                }
-                            }
-                        } else if (action == 'deleteObject') {
-                            if (isFilter && data.returnObject != false) {
-                                const cursor = arrayObj.find(query).sort(sort).skip(index).limit(limit);
-                                while (await cursor.hasNext()) {
-                                    const document = await cursor.next();
-
-                                    if (data.filter && data.filter.search) {
-                                        let isMatch = searchData(document, data.filter.search)
+                                    if (data.$filter && data.$filter.search) {
+                                        let isMatch = searchData(document, data.$filter.search)
                                         if (!isMatch)
                                             continue;
                                     }
 
-                                    arrayObj.deleteOne({
-                                        _id: document._id
-                                    }).then((result) => {
-                                        documents.push({ _id: document._id, storage: data.storageName, database, array })
-                                    }).catch((error) => {
-                                        errorHandler(data, error, database, array)
-                                        console.log(action, 'error', error);
-                                    });
-                                }
+                                    if (action === 'readObject') {
+                                        documents.push({ ...document, ...reference, _id: document._id.toString() })
+                                    } else {
+                                        dataTransferedOut += getBytes({ _id: document._id, update, options })
 
-                            }
+                                        let result
+                                        if (action === 'updateObject') {
+                                            result = await arrayObj.updateOne({ _id: document._id }, update, options);
+                                        } else if (action === 'deleteObject') {
+                                            result = await arrayObj.deleteOne({ _id: document._id });
+                                        }
 
-                            let _ids = [];
-                            for (let i = 0; i < data[type].length; i++) {
-                                if (data[type][i]._id) {
-                                    _ids.push(ObjectId(data[type][i]._id))
-                                    documents.push({ _id: data[type][i]._id, storage: data.storageName, database, array })
+                                        dataTransferedIn += getBytes(result)
+                                        documents.push({ ...data[type][i], ...reference, _id: document._id.toString() })
+                                    }
+                                    document = ''
                                 }
+                            } catch (error) {
+                                errorHandler(data, error, database, array)
                             }
+                        }
+                    }
 
-                            if (_ids.length == 1)
-                                query['_id'] = _ids[0]
-                            else if (_ids.length)
-                                query['_id'] = { $in: _ids }
-
-                            arrayObj.deleteMany(query, function (error, result) {
-                                arraysLength -= 1
-                                if (!arraysLength)
-                                    databasesLength -= 1
-
-                                if (!databasesLength && !arraysLength) {
-                                    data = createData(data, documents, type)
-                                    resolve(data)
-                                }
-
-                            })
+                    if (action === 'createObject') {
+                        try {
+                            dataTransferedOut += getBytes(data[type])
+                            const result = await arrayObj.insertMany(data[type]);
+                            dataTransferedIn += getBytes(result)
+                        } catch (error) {
+                            errorHandler(data, error, database, array)
                         }
                     }
 
                 }
             }
 
+            data = createData(data, documents, type, dataTransferedIn, dataTransferedOut)
+            resolve(data)
+
         } catch (error) {
             errorHandler(data, error)
             console.log(action, 'error', error);
@@ -527,156 +409,120 @@ function object(action, data) {
 
 }
 
-function createUpdate(data, type, index) {
-    let update = {}, projection = {};
-    if (data[type][index]) {
-        update['$set'] = data[type][index]
-        update['$set']['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
-        update['$set']['organization_id'] = data.organization_id
-
-        if (update['$set']['_id'])
-            delete update['$set']['_id']
-
-        Object.keys(update['$set']).forEach(key => {
-            if (key.includes('$rename') || key.includes('$update')) {
-
-            } else if (key.includes('$delete')) {
-
-            } else if (key.includes('$inc')) {
-                update['$inc'] = update['$set'][key]
-                delete update['$set'][key]
-            } else if (key.endsWith(']')) {
-                // Use a regular expression to extract the key and index (including a potentially undefined or keyword index)
-                const regex = /^(.*(?:\[\d+\].*?)?)\[(.*?)\](?:\[\])?$/;
-                const match = inputString.match(regex);
-                const index = parseInt(match[2], 10);
-
-                if (index && index !== -1 && index !== 1 && update['$set'][key] === '$delete') {
-                    match[1] = replaceArray({ [update['$set'][key]]: update['$set'][key] });
-                    match[1] = Object.keys(match[1])[0]
-
-                    if (!update['$unset'])
-                        update['$unset'] = {}
-
-                    update.$unset[match[1]] = 1;
-
-                    if (!update['$pull'])
-                        update['$pull'] = {}
-
-                    update.$pull[match[1]] = null;
-                } else {
-                    match[1] = replaceArray({ [match[1]]: update['$set'][key] });
-                    match[1] = Object.keys(match[1])[0]
-
-                    if (update['$set'][key] === '$pop' || update['$set'][key] === '$delete') {
-                        if (!update['$pop'])
-                            update['$pop'] = {}
-
-                        update.$pop[match[1]] = index || 1
-                    } else if (match[2] === '$addToSet') {
-                        if (!update['$addToSet'])
-                            update['$addToSet'] = {}
-
-                        update.$addToSet[match[1]] = update['$set'][key]
-                    } else if (match[2] === '$pull') {
-                        if (!update['$pull'])
-                            update['$pull'] = {}
+function createUpdate(update, options, data, isGlobal) {
+    if (data.upsert)
+        options.upsert = data.upsert
+    if (data.$upsert)
+        options.upsert = data.$upsert
+
+    Object.keys(data).forEach(key => {
+        if (isGlobal && !key.startsWith('$') || key === '_id')
+            return
+
+        let operator
+        if (key.endsWith(']')) {
+            const regex = /^(.*(?:\[\d+\].*?)?)\[(.*?)\](?:\[\])?$/;
+            var match = key.match(regex);
+            var index = parseInt(match[2], 10);
+            if (index === NaN)
+                operator = match[2]
+            var arrayKey = match[1].replace(/\[(\d+)\]/g, '.$1');
+        }
 
-                        update.$pull[match[1]] = update['$set'][key]
-                    } else {
-                        if (!Array.isArray(update['$set'][key]))
-                            update['$set'][key] = [update['$set'][key]]
+        if (key.startsWith('$'))
+            operator = key.split('.')[0]
+        else if (!operator && typeof data[key] === 'string' && data[key].startsWith('$'))
+            operator = data[key]
 
-                        let insert = { $each: update['$set'][key] }
-                        if (index)
-                            insert.$postion = match[2]
+        if (!update['$set'])
+            update['$set'] = {}
 
-                        if (!update['$push'])
-                            update['$push'] = {}
+        let originalKey = key
+        key = key.replace(/\[(\d+)\]/g, '.$1');
 
-                        update.$push[match[1]] = insert
+        let operators = ['$rename', '$inc', '$push', '$splice', '$unset', '$delete', '$slice', '$pop']
+        if (!operators.includes(operator) && typeof index !== 'number') {
+            if (!isGlobal)
+                update['$set'][key] = data[originalKey]
+            return
+        }
 
-                    }
+        let updates = {}
+        if (operator === '$rename') {
+            if (key === '$rename')
+                for (let oldkey of Object.keys(data[originalKey])) {
+                    key = '$rename.' + oldkey
+                    updates[key] = data[originalKey][oldkey].replace(/\[(\d+)\]/g, '.$1')
                 }
+            else
+                updates[key] = data[originalKey].replace(/\[(\d+)\]/g, '.$1')
+
+        } else if (operator === '$delete' || operator === '$unset' || operator === '$slice') {
+            operator = '$unset'
+            updates[key] = 1
+            if (!updates['$pull'])
+                updates['$pull'] = {}
+            updates['$pull'][key] = null
+        } else if (operator === '$pop') {
+            key = arrayKey
+            updates[key] = index || 1
+        } else if (operator === '$addToSet' || operator === '$pull') {
+            key = arrayKey
+            updates[key] = data[originalKey]
+        } else if (operator === '$push' || typeof index === 'number') {
+            if (!Array.isArray(data[originalKey]))
+                updates[key] = [data[originalKey]]
+            else
+                updates[key] = data[originalKey]
 
-                delete update['$set'][key]
-
-            }
-            projection[key] = 1
-        })
-    }
-
-    if (data['deleteName']) {
-        update['$unset'] = replaceArray(data['deleteName']);
-    }
+            let insert = { $each: updates[key] }
+            if (typeof index === 'number' && index >= 0)
+                insert.$postion = index
 
-    if (data['updateName']) {
-        update['$rename'] = replaceArray(data['updateName'])
-        for (const [key, value] of Object.entries(update['$rename'])) {
-            if (/\.([0-9]*)/g.test(key) || /\[([0-9]*)\]/g.test(value)) {
-                console.log('key is array', /\[([0-9]*)\]/g.test(value), /\.([0-9]*)/g.test(key))
-            } else {
-                let newValue = replaceArray({ [value]: value })
-                let oldkey = key;
-                for (const [key] of Object.entries(newValue)) {
-                    update['$rename'][oldkey] = key
-                }
-            }
+            updates[key] = insert
+        } else if (operator === '$inc') {
+            updates[key] = data[originalKey]
         }
-    }
 
-    return { update, projection }
+        if (!update[operator])
+            update[operator] = {}
 
+        if (key === operator)
+            update[operator] = { ...update[operator], ...replaceArray(updates[key]) }
+        else
+            update[operator][key.replace(operator, '')] = updates[key]
+    })
 }
 
-function createData(data, array, type) {
-    if (!data.request)
-        data.request = data[type] || {}
-
-    if (data.filter && data.filter.sort)
-        data[type] = sortData(array, data.filter.sort)
-    else
-        data[type] = array
+async function createFilter(data, arrayObj) {
+    let query = {}, sort = {}, index = 0, limit = 0, count
 
-    if (data.returnLog) {
-        if (!data.log)
-            data.log = []
-        data.log.push(...data[type])
-    }
-
-    return data
-}
+    if (data.$filter) {
+        if (data.$filter.query)
+            query = createQuery(data.$filter.query);
 
-async function getFilters(data, arrayObj) {
-    let query =
-        {}, sort = {}, index = 0, limit = 0, count
-    if (data.filter) {
 
-        if (data.filter.query)
-            query = createQuery(data.filter.query);
-
-
-        if (data.filter.sort) {
-            for (let i = 0; i < data.filter.sort.length; i++) {
-                let direction = data.filter.sort[i].direction
+        if (data.$filter.sort) {
+            for (let i = 0; i < data.$filter.sort.length; i++) {
+                let direction = data.$filter.sort[i].direction
                 if (direction == 'desc' || direction == -1)
                     direction = -1;
                 else
                     direction = 1;
 
-                sort[data.filter.sort[i].key] = direction
+                sort[data.$filter.sort[i].key] = direction
             }
         }
 
         if (arrayObj) {
             count = await arrayObj.estimatedDocumentCount()
-            data.filter.count = count
+            data.$filter.count = count
         }
 
-        if (data.filter.index)
-            index = data.filter.index
-        if (data.filter.limit)
-            limit = data.filter.limit
+        if (data.$filter.index)
+            index = data.$filter.index
+        if (data.$filter.limit)
+            limit = data.$filter.limit
         if (limit)
             limit = index + limit;
     }
@@ -687,6 +533,7 @@ async function getFilters(data, arrayObj) {
     return { query, sort, index, limit, count }
 }
 
+
 // TODO: improve mongodb query to cover many cases
 function createQuery(queries) {
     let query = new Object();
@@ -742,6 +589,13 @@ function createQuery(queries) {
                 else
                     query[key] = { $in: item.value }
                 break;
+            case '$or':
+                if (!query[item.operator])
+                    query[item.operator] = [{ [key]: item.value }];
+                else
+                    query[item.operator].push({ [key]: item.value })
+                delete query[key]
+                break;
             case '$geoWithin':
                 try {
                     let value = JSON.parse(item.value);
@@ -766,6 +620,63 @@ function createQuery(queries) {
     return query;
 }
 
+function createProjection(data) {
+    let projection = {}
+
+    Object.keys(data).forEach((key) => {
+        if (!['_id', 'organization_id'].includes(key) && !key.startsWith('$'))
+            projection[key.replace(/\[(\d+)\]/g, '.$1')] = 1
+    });
+
+    return projection;
+}
+
+function replaceArray(data) {
+    let object = {}
+
+    Object.keys(data).forEach((key) => {
+        object[key.replace(/\[(\d+)\]/g, '.$1')] = data[key]
+    });
+
+    return object;
+}
+
+function createData(data, array, type, dataTransferedIn, dataTransferedOut) {
+    if (dataTransferedIn) {
+        process.emit("setBandwidth", {
+            type: 'in',
+            data: dataTransferedIn,
+            organization_id: data.organization_id
+        });
+    }
+
+    if (dataTransferedOut) {
+        process.emit("setBandwidth", {
+            type: 'out',
+            data: dataTransferedOut,
+            organization_id: data.organization_id
+        });
+    }
+
+    if (!data.request)
+        data.request = data[type] || {}
+
+    data[type] = array
+
+    if (data.returnLog) {
+        if (!data.log)
+            data.log = []
+        data.log.push(...data[type])
+    }
+
+    return data
+}
+
+function getBytes(data) {
+    const jsonString = JSON.stringify(data);
+    return Buffer.byteLength(jsonString, 'utf8');
+}
+
 function errorHandler(data, error, database, array) {
     if (typeof error == 'object')
         error['storage'] = 'mongodb'
@@ -782,40 +693,4 @@ function errorHandler(data, error, database, array) {
         data.error = [error]
 }
 
-function replaceArray(data) {
-    let keys = Object.keys(data);
-    let objectData = {};
-
-    keys.forEach((k) => {
-        let nk = k
-        if (/\[([0-9]*)\]/g.test(k)) {
-            nk = nk.replace(/\[/g, '.');
-            if (nk.endsWith(']'))
-                nk = nk.slice(0, -1)
-            nk = nk.replace(/\]./g, '.');
-            nk = nk.replace(/\]/g, '.');
-        }
-        objectData[nk] = data[k];
-    });
-
-    return objectData;
-}
-
-
-module.exports = {
-    databaseStats,
-    createDatabase,
-    readDatabase,
-    updateDatabase,
-    deleteDatabase,
-
-    createCollection,
-    readCollection,
-    updateCollection,
-    deleteCollection,
-
-    createObject,
-    readObject,
-    updateObject,
-    deleteObject,
-}
+module.exports = { send }