@cocreate/crud-server 1.22.0 → 1.22.2

package/src/index.js

@@ -1,241 +1,241 @@
-'use strict';
-
-const { ObjectId, searchData, sortData } = require("@cocreate/utils");
-
-class CoCreateCrudServer {
-    constructor(wsManager, databases, db) {
-        this.wsManager = wsManager
-        this.databases = databases
-        this.db = db
-        this.ObjectId = ObjectId
-        this.dbUrls = new Map();
-        this.init();
-    }
-
-    init() {
-        if (this.wsManager) {
-            this.wsManager.on('createDatabase', (socket, data) => this.crud(socket, 'createDatabase', data))
-            this.wsManager.on('readDatabase', (socket, data) => this.crud(socket, 'readDatabase', data))
-            this.wsManager.on('updateDatabase', (socket, data) => this.crud(socket, 'updateDatabase', data))
-            this.wsManager.on('deleteDatabase', (socket, data) => this.crud(socket, 'deleteDatabase', data))
-            this.wsManager.on('createCollection', (socket, data) => this.crud(socket, 'createCollection', data))
-            this.wsManager.on('readCollection', (socket, data) => this.crud(socket, 'readCollection', data))
-            this.wsManager.on('updateCollection', (socket, data) => this.crud(socket, 'updateCollection', data))
-            this.wsManager.on('deleteCollection', (socket, data) => this.crud(socket, 'deleteCollection', data))
-            this.wsManager.on('createDocument', (socket, data) => this.crud(socket, 'createDocument', data))
-            this.wsManager.on('readDocument', (socket, data) => this.crud(socket, 'readDocument', data))
-            this.wsManager.on('updateDocument', (socket, data) => this.crud(socket, 'updateDocument', data))
-            this.wsManager.on('deleteDocument', (socket, data) => this.crud(socket, 'deleteDocument', data))
-        }
-    }
-
-    async databaseStats(data) {
-        data = await this.crud('', 'databaseStats', data)
-        return data
-    }
-
-    async createDatabase(data) {
-        data = await this.crud('', 'createDatabase', data)
-        return data
-    }
-
-    async readDatabase(data) {
-        data = await this.crud('', 'readDatabase', data)
-        return data
-    }
-
-    async updateDatabase(data) {
-        data = await this.crud('', 'updateDatabase', data)
-        return data
-    }
-
-    async deleteDatabase(data) {
-        data = await this.crud('', 'deleteDatabase', data)
-        return data
-    }
-
-    async createCollection(data) {
-        data = await this.crud('', 'createCollection', data)
-        return data
-    }
-
-    async readCollection(data) {
-        data = await this.crud('', 'readCollection', data)
-        return data
-    }
-
-    async updateCollection(data) {
-        data = await this.crud('', 'updateCollection', data)
-        return data
-    }
-
-    async deleteCollection(data) {
-        data = await this.crud('', 'deleteCollection', data)
-        return data
-    }
-
-    async createDocument(data) {
-        data = await this.crud('', 'createDocument', data)
-        return data
-    }
-
-    async readDocument(data) {
-        data = await this.crud('', 'readDocument', data)
-        return data
-    }
-
-    async updateDocument(data) {
-        data = await this.crud('', 'updateDocument', data)
-        return data
-    }
-
-    async deleteDocument(data) {
-        data = await this.crud('', 'deleteDocument', data)
-        return data
-    }
-
-    async crud(socket, action, data) {
-        return new Promise(async (resolve) => {
-            try {
-                if (!data.organization_id)
-                    return resolve()
-
-                let dbUrl = this.dbUrls.get(data.organization_id)
-                if (dbUrl === false)
-                    return resolve({ dbUrl: false, error: 'database url could not be found' })
-
-                if (!dbUrl) {
-                    if (data.organization_id === process.env.organization_id) {
-                        dbUrl = this.db
-                        this.dbUrls.set(data.organization_id, dbUrl)
-                    } else {
-                        let organization = await this.readDocument({
-                            database: process.env.organization_id,
-                            collection: 'organizations',
-                            document: [{ _id: data.organization_id }],
-                            organization_id: process.env.organization_id
-                        })
-                        if (organization && organization.document && organization.document[0])
-                            organization = organization.document[0]
-                        if (organization && organization.databases) {
-                            dbUrl = organization.databases
-                            this.dbUrls.set(data.organization_id, dbUrl)
-                        } else {
-                            this.dbUrls.set(data.organization_id, false)
-                            if (organization)
-                                return resolve({ dbUrl: false, error: 'database url could not be found' })
-                            else
-                                return resolve({ organization: false, error: 'organization could not be found' })
-                        }
-                    }
-                }
-
-                if (!data['timeStamp'])
-                    data['timeStamp'] = new Date().toISOString()
-
-                if (action == 'updateDocument' && data.upsert != false)
-                    data.upsert = true
-
-                // TODO: support stats from multiple dbs 
-                if (data.collection || action === 'databaseStats') {
-                    if (!data.database)
-                        data['database'] = data.organization_id
-
-                    if (action === 'updateDocument' && data.organization_id !== process.env.organization_id) {
-                        let syncKeys
-                        if (data.collection === 'organizations')
-                            syncKeys = ['name', 'logo', 'databases', 'hosts', 'apis']
-                        else if (data.collection === 'users')
-                            syncKeys = ['name', 'email', 'password', 'avatar']
-
-                        if (syncKeys && syncKeys.length) {
-                            let platformUpdate = {
-                                database: process.env.organization_id,
-                                collection: data.collection,
-                                document: [{}],
-                                organization_id: process.env.organization_id
-                            }
-
-                            let document = data.document[0] || data.document
-                            if (document) {
-                                for (let key of syncKeys) {
-                                    if (document[key])
-                                        platformUpdate.document[0][key] = document[key]
-                                }
-                            }
-
-                            this[action](platformUpdate)
-                        }
-
-                    }
-
-                }
-
-                if (!data.db || !data.db.length) {
-                    data.db = [Object.keys(dbUrl)[0]]
-                } else if (!Array.isArray(data.db))
-                    data.db = [data.db]
-
-                for (let i = 0; i < data.db.length; i++) {
-                    if (dbUrl && dbUrl[data.db[i]]) {
-                        let db = dbUrl[data.db[i]]
-
-                        if (db.provider && this.databases[db.provider]) {
-                            if (!Array.isArray(db.url))
-                                db.url = [db.url]
-                            for (let i = 0; i < db.url.length; i++) {
-                                data['dbUrl'] = db.url[i]
-                                data = await this.databases[db.provider][action](data)
-                            }
-
-                            //TODO: sorting should take place here in order to return sorted values from multiple dbs
-                        }
-                    }
-                }
-
-                delete data.dbUrl
-                if (socket) {
-                    if (data.organization_id === process.env.organization_id && socket.config.organization_id !== data.organization_id) {
-                        this.wsManager.broadcast({
-                            config: {
-                                organization_id: process.env.organization_id,
-                            }
-                        }, action, { ...data });
-                        data.organization_id = socket.config.organization_id
-                    }
-
-                    this.wsManager.broadcast(socket, action, data);
-                    process.emit('changed-document', data)
-                    resolve()
-                } else {
-                    resolve(data)
-                }
-            } catch (error) {
-                if (socket) {
-                    this.errorHandler(data, error)
-                    this.wsManager.send(socket, action, data);
-                    resolve()
-                } else {
-                    resolve(data)
-                }
-            }
-        });
-    }
-
-    errorHandler(data, error, database, collection) {
-        if (typeof error == 'object')
-            error['db'] = 'mongodb'
-        else
-            error = { location: 'crudServer', message: error }
-
-        if (database)
-            error['database'] = database
-
-        if (data.error)
-            data.error.push(error)
-        else
-            data.error = [error]
-    }
-}
-
+'use strict';
+
+const { ObjectId, searchData, sortData } = require("@cocreate/utils");
+
+class CoCreateCrudServer {
+    constructor(wsManager, databases, db) {
+        this.wsManager = wsManager
+        this.databases = databases
+        this.db = db
+        this.ObjectId = ObjectId
+        this.dbUrls = new Map();
+        this.init();
+    }
+
+    init() {
+        if (this.wsManager) {
+            this.wsManager.on('createDatabase', (socket, data) => this.crud(socket, 'createDatabase', data))
+            this.wsManager.on('readDatabase', (socket, data) => this.crud(socket, 'readDatabase', data))
+            this.wsManager.on('updateDatabase', (socket, data) => this.crud(socket, 'updateDatabase', data))
+            this.wsManager.on('deleteDatabase', (socket, data) => this.crud(socket, 'deleteDatabase', data))
+            this.wsManager.on('createCollection', (socket, data) => this.crud(socket, 'createCollection', data))
+            this.wsManager.on('readCollection', (socket, data) => this.crud(socket, 'readCollection', data))
+            this.wsManager.on('updateCollection', (socket, data) => this.crud(socket, 'updateCollection', data))
+            this.wsManager.on('deleteCollection', (socket, data) => this.crud(socket, 'deleteCollection', data))
+            this.wsManager.on('createDocument', (socket, data) => this.crud(socket, 'createDocument', data))
+            this.wsManager.on('readDocument', (socket, data) => this.crud(socket, 'readDocument', data))
+            this.wsManager.on('updateDocument', (socket, data) => this.crud(socket, 'updateDocument', data))
+            this.wsManager.on('deleteDocument', (socket, data) => this.crud(socket, 'deleteDocument', data))
+        }
+    }
+
+    async databaseStats(data) {
+        data = await this.crud('', 'databaseStats', data)
+        return data
+    }
+
+    async createDatabase(data) {
+        data = await this.crud('', 'createDatabase', data)
+        return data
+    }
+
+    async readDatabase(data) {
+        data = await this.crud('', 'readDatabase', data)
+        return data
+    }
+
+    async updateDatabase(data) {
+        data = await this.crud('', 'updateDatabase', data)
+        return data
+    }
+
+    async deleteDatabase(data) {
+        data = await this.crud('', 'deleteDatabase', data)
+        return data
+    }
+
+    async createCollection(data) {
+        data = await this.crud('', 'createCollection', data)
+        return data
+    }
+
+    async readCollection(data) {
+        data = await this.crud('', 'readCollection', data)
+        return data
+    }
+
+    async updateCollection(data) {
+        data = await this.crud('', 'updateCollection', data)
+        return data
+    }
+
+    async deleteCollection(data) {
+        data = await this.crud('', 'deleteCollection', data)
+        return data
+    }
+
+    async createDocument(data) {
+        data = await this.crud('', 'createDocument', data)
+        return data
+    }
+
+    async readDocument(data) {
+        data = await this.crud('', 'readDocument', data)
+        return data
+    }
+
+    async updateDocument(data) {
+        data = await this.crud('', 'updateDocument', data)
+        return data
+    }
+
+    async deleteDocument(data) {
+        data = await this.crud('', 'deleteDocument', data)
+        return data
+    }
+
+    async crud(socket, action, data) {
+        return new Promise(async (resolve) => {
+            try {
+                if (!data.organization_id)
+                    return resolve()
+
+                let dbUrl = this.dbUrls.get(data.organization_id)
+                if (dbUrl === false)
+                    return resolve({ dbUrl: false, error: 'database url could not be found' })
+
+                if (!dbUrl) {
+                    if (data.organization_id === process.env.organization_id) {
+                        dbUrl = this.db
+                        this.dbUrls.set(data.organization_id, dbUrl)
+                    } else {
+                        let organization = await this.readDocument({
+                            database: process.env.organization_id,
+                            collection: 'organizations',
+                            document: [{ _id: data.organization_id }],
+                            organization_id: process.env.organization_id
+                        })
+                        if (organization && organization.document && organization.document[0])
+                            organization = organization.document[0]
+                        if (organization && organization.databases) {
+                            dbUrl = organization.databases
+                            this.dbUrls.set(data.organization_id, dbUrl)
+                        } else {
+                            this.dbUrls.set(data.organization_id, false)
+                            if (organization)
+                                return resolve({ dbUrl: false, error: 'database url could not be found' })
+                            else
+                                return resolve({ organization: false, error: 'organization could not be found' })
+                        }
+                    }
+                }
+
+                if (!data['timeStamp'])
+                    data['timeStamp'] = new Date().toISOString()
+
+                if (action == 'updateDocument' && data.upsert != false)
+                    data.upsert = true
+
+                // TODO: support stats from multiple dbs 
+                if (data.collection || action === 'databaseStats') {
+                    if (!data.database)
+                        data['database'] = data.organization_id
+
+                    if (action === 'updateDocument' && data.organization_id !== process.env.organization_id) {
+                        let syncKeys
+                        if (data.collection === 'organizations')
+                            syncKeys = ['name', 'logo', 'databases', 'hosts', 'apis']
+                        else if (data.collection === 'users')
+                            syncKeys = ['name', 'email', 'password', 'avatar']
+
+                        if (syncKeys && syncKeys.length) {
+                            let platformUpdate = {
+                                database: process.env.organization_id,
+                                collection: data.collection,
+                                document: [{}],
+                                organization_id: process.env.organization_id
+                            }
+
+                            let document = data.document[0] || data.document
+                            if (document) {
+                                for (let key of syncKeys) {
+                                    if (document[key])
+                                        platformUpdate.document[0][key] = document[key]
+                                }
+                            }
+
+                            this[action](platformUpdate)
+                        }
+
+                    }
+
+                }
+
+                if (!data.db || !data.db.length) {
+                    data.db = [Object.keys(dbUrl)[0]]
+                } else if (!Array.isArray(data.db))
+                    data.db = [data.db]
+
+                for (let i = 0; i < data.db.length; i++) {
+                    if (dbUrl && dbUrl[data.db[i]]) {
+                        let db = dbUrl[data.db[i]]
+
+                        if (db.provider && this.databases[db.provider]) {
+                            if (!Array.isArray(db.url))
+                                db.url = [db.url]
+                            for (let i = 0; i < db.url.length; i++) {
+                                data['dbUrl'] = db.url[i]
+                                data = await this.databases[db.provider][action](data)
+                            }
+
+                            //TODO: sorting should take place here in order to return sorted values from multiple dbs
+                        }
+                    }
+                }
+
+                delete data.dbUrl
+                if (socket) {
+                    if (data.organization_id === process.env.organization_id && socket.config.organization_id !== data.organization_id) {
+                        this.wsManager.broadcast({
+                            config: {
+                                organization_id: process.env.organization_id,
+                            }
+                        }, action, { ...data });
+                        data.organization_id = socket.config.organization_id
+                    }
+
+                    this.wsManager.broadcast(socket, action, data);
+                    process.emit('changed-document', data)
+                    resolve()
+                } else {
+                    resolve(data)
+                }
+            } catch (error) {
+                if (socket) {
+                    this.errorHandler(data, error)
+                    this.wsManager.send(socket, action, data);
+                    resolve()
+                } else {
+                    resolve(data)
+                }
+            }
+        });
+    }
+
+    errorHandler(data, error, database, collection) {
+        if (typeof error == 'object')
+            error['db'] = 'mongodb'
+        else
+            error = { location: 'crudServer', message: error }
+
+        if (database)
+            error['database'] = database
+
+        if (data.error)
+            data.error.push(error)
+        else
+            data.error = [error]
+    }
+}
+
 module.exports = CoCreateCrudServer;