@cocreate/mongodb 1.1.25 → 1.2.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.2.0](https://github.com/CoCreate-app/CoCreate-mongodb/compare/v1.1.25...v1.2.0) (2023-03-19)
+
+
+### Features
+
+* dynamically connect to user defined dbUrl ([343ab8e](https://github.com/CoCreate-app/CoCreate-mongodb/commit/343ab8e5a72683a3be74c24acfc4489198564c10))
+
 ## [1.1.25](https://github.com/CoCreate-app/CoCreate-mongodb/compare/v1.1.24...v1.1.25) (2023-02-01)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/mongodb",
-  "version": "1.1.25",
+  "version": "1.2.0",
   "description": "A simple mongodb component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "mongodb",

package/src/index.js

@@ -1,13 +1,14 @@
-const {MongoClient, ObjectId} = require('mongodb');
-const {dotNotationToObject, queryData, searchData, sortData} = require('@cocreate/utils')
+const { MongoClient, ObjectId } = require('mongodb');
+const { dotNotationToObject, queryData, searchData, sortData } = require('@cocreate/utils')
+const clients = new Map()
 
-function mongoClient(dbUrl) {
+async function mongoClient(dbUrl) {
 	try {
 		dbUrl = dbUrl || process.env.MONGO_URL;
 		if (!dbUrl || !dbUrl.includes('mongodb'))
 			console.log('CoCreate.config.js missing dbUrl')
-		dbClient = MongoClient.connect(dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
-		return dbClient;
+		const Client = MongoClient.connect(dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
+		return Client;
 	} catch (error) {
 		console.error(error)
 		return {
@@ -16,13 +17,28 @@ function mongoClient(dbUrl) {
 	}
 }
 
-let dbClient;
+let platformClient;
 mongoClient().then(Client => {
-	dbClient = Client
+	platformClient = Client
 });
 
+async function dbClient(data) {
+	// ToDo: provide platform client only to specific collections ['permissions', 'metrics', 'organizations', 'users']
+	if (!data.dbs)
+		return platformClient
+	let client = clients.get(data.dbs)
+	if (!client) {
+		client = await mongoClient(data.dbs)
+		clients.set(data.dbs, client)
+	}
+	return client
+}
+
 async function databaseStats(data) {
-	let stats = await dbClient.db(data.organization_id).stats()
+	const client = await dbClient(data)
+	if (!client) return
+	let db = client.db(data.organization_id)
+	let stats = db.stats()
 	return stats
 }
 
@@ -42,35 +58,36 @@ function deleteDatabase(data) {
 	return database('deleteDatabase', data)
 }
 
-function database(action, data){
-	return new Promise((resolve, reject) => {
+function database(action, data) {
+	return new Promise(async (resolve, reject) => {
 		let type = 'database'
 		let databaseArray = []
-		
+
 		try {
+			const client = await dbClient(data)
+			if (!client) return
 			if (action == 'readDatabase') {
-				let db = dbClient.db().admin();
+				const db = client.db().admin();
 
 				// List all the available databases
-				db.listDatabases(function(err, dbs) {
-									
-					for (let database of dbs.databases){
+				db.listDatabases(function (err, dbs) {
+
+					for (let database of dbs.databases) {
 						let isFilter = queryData(database, data.filter.query)
 						if (isFilter)
-							databaseArray.push({database, db: 'mongodb'})
+							databaseArray.push({ database, db: 'mongodb' })
 					}
-					
-					resolve(createData(data, databaseArray, type))	
+
+					resolve(createData(data, databaseArray, type))
 				})
-	
 			}
 			if (action == 'deleteDatabase') {
-				const db = dbClient.db(data.database);
+				const db = client.db(data.database);
 				db.dropDatabase().then(response => {
 					resolve(response)
 				})
 			}
-		} catch(error) {
+		} catch (error) {
 			errorHandler(data, error)
 			console.log(action, 'error', error);
 			resolve(data);
@@ -82,7 +99,7 @@ function database(action, data){
 }
 
 
-function createCollection(data){
+function createCollection(data) {
 	return collection('createCollection', data)
 }
 
@@ -98,94 +115,98 @@ function deleteCollection(data) {
 	return collection('deleteCollection', data)
 }
 
-function collection(action, data){
-	return new Promise((resolve, reject) => {
+function collection(action, data) {
+	return new Promise(async (resolve, reject) => {
 		let type = 'collection'
 		let collectionArray = [];
-		
+
 		try {
+			const client = await dbClient(data)
+			if (!client) return
+
 			if (data.request)
 				data.collection = data.request
 
-			let databases = data.database;  
+			let databases = data.database;
 			if (!Array.isArray(databases))
 				databases = [databases]
 
 			let databasesLength = databases.length
 			for (let database of databases) {
-				const db = dbClient.db(database);
+				const db = client.db(database);
+
 				if (action == 'readCollection') {
 
-					let {query, sort} = getFilters(data);
+					let { query, sort } = getFilters(data);
 
-					db.listCollections().toArray(function(error, result) {
+					db.listCollections().toArray(function (error, result) {
 						if (error)
 							errorHandler(data, error, database)
-						
+
 						if (result) {
 							for (let res of result) {
 								let isFilter = queryData(res, data.filter.query)
 								if (isFilter)
-									collectionArray.push({name: res.name, database, db: 'mongodb'})
+									collectionArray.push({ name: res.name, database, db: 'mongodb' })
 							}
 						}
 
 						databasesLength -= 1
 						if (!databasesLength) {
 							data = createData(data, collectionArray, type)
-							resolve(data)					
+							resolve(data)
 						}
-					})		
+					})
 				} else {
 					let collections
 					let value
 					if (action == 'updateCollection')
 						collections = Object.entries(data.collection)
 					else
-						collections = data.collection;				
-					
+						collections = data.collection;
+
 					if (!Array.isArray(collections))
 						collections = [collections]
 
 					let collectionsLength = collections.length
 					for (let collection of collections) {
-						
+
 						if (action == 'createCollection') {
-							db.createCollection(collection, function(error, result) {
+							db.createCollection(collection, function (error, result) {
 								if (error)
 									errorHandler(data, error, database, collection)
 
 								if (result)
-									collectionArray.push({name: collection, database, db: 'mongodb'})
+									collectionArray.push({ name: collection, database, db: 'mongodb' })
 
-								collectionsLength -= 1           
+								collectionsLength -= 1
 								if (!collectionsLength)
 									databasesLength -= 1
-								
+
 								if (!databasesLength && !collectionsLength) {
 									data = createData(data, collectionArray, type)
-									resolve(data)					
+									resolve(data)
 								}
 							})
 						} else {
 							if (action == 'updateCollection') {
 								[collection, value] = collection
 							}
-	
+
 							const collectionObj = db.collection(collection);
 
 							if (action == 'updateCollection') {
-								collectionObj.rename(value, function(error, result) {
+								collectionObj.rename(value, function (error, result) {
 									if (error)
 										errorHandler(data, error, database, collection)
-					
+
 									if (result)
-										collectionArray.push({name: value, oldName: collection, database, db: 'mongodb'})
-									
-									collectionsLength -= 1           
+										collectionArray.push({ name: value, oldName: collection, database, db: 'mongodb' })
+
+									collectionsLength -= 1
 									if (!collectionsLength)
 										databasesLength -= 1
-									
+
 									if (!databasesLength && !collectionsLength) {
 										data = createData(data, collectionArray, type)
 										resolve(data)
@@ -195,31 +216,32 @@ function collection(action, data){
 							}
 
 							if (action == 'deleteCollection') {
-								collectionObj.drop( function(error, result) {
+								collectionObj.drop(function (error, result) {
 									if (error)
 										errorHandler(data, error, database, collection)
-									
+
 									if (result)
-										collectionArray.push({name: collection, database, db: 'mongodb'})
-									
-									collectionsLength -= 1           
+										collectionArray.push({ name: collection, database, db: 'mongodb' })
+
+									collectionsLength -= 1
 									if (!collectionsLength)
 										databasesLength -= 1
-									
+
 									if (!databasesLength && !collectionsLength) {
 										data = createData(data, collectionArray, type)
 										resolve(data)
 									}
 
 								})
-								
+
 							}
 						}
 
 					}
 				}
 			}
-		} catch(error) {
+
+		} catch (error) {
 			errorHandler(data, error)
 			console.log(action, 'error', error);
 			resolve(data);
@@ -230,7 +252,7 @@ function collection(action, data){
 }
 
 
-function createDocument(data){
+function createDocument(data) {
 	return document('createDocument', data)
 }
 
@@ -246,9 +268,12 @@ function deleteDocument(data) {
 	return document('deleteDocument', data)
 }
 
-function document(action, data){
+function document(action, data) {
 	return new Promise(async (resolve, reject) => {
 		try {
+			const client = await dbClient(data)
+			if (!client) return
+	
 			let type = 'document'
 			let documents = [];
 
@@ -258,13 +283,13 @@ function document(action, data){
 
 			if (!data['timeStamp'])
 				data['timeStamp'] = new Date().toISOString()
-	
+
 
 			let isFilter
 			if (data.filter && data.filter.query)
 				isFilter = true
-	
-			let databases = data.database;  
+
+			let databases = data.database;
 			if (!Array.isArray(databases))
 				databases = [databases]
 
@@ -276,10 +301,10 @@ function document(action, data){
 
 				let collectionsLength = collections.length
 				for (let collection of collections) {
-					const db = dbClient.db(database);
+					const db = client.db(database);
 					const collectionObj = db.collection(collection);
-					
-					let {query, sort} = getFilters(data);
+
+					let { query, sort } = getFilters(data);
 					if (data['organization_id']) {
 						query['organization_id'] = { $eq: data['organization_id'] }
 					}
@@ -301,54 +326,54 @@ function document(action, data){
 
 								if (!data[type][i]._id)
 									data[type][i]._id = ObjectId()
-								else 
+								else
 									data[type][i]._id = ObjectId(data[type][i]._id)
-								data[type][i]['created'] = {on: data.timeStamp, by: data.user_id || data.clientId}
+								data[type][i]['created'] = { on: data.timeStamp, by: data.user_id || data.clientId }
 							}
 							if (action == 'readDocument' && data[type][i]._id) {
 								_ids.push(ObjectId(data[type][i]._id))
 							}
-							if (action =='updateDocument') {
+							if (action == 'updateDocument') {
 								if (data[type][i]._id)
-									update_ids.push({_id: data[type][i]._id, updateDoc: data[type][i], updateType: '_id'})
-							
+									update_ids.push({ _id: data[type][i]._id, updateDoc: data[type][i], updateType: '_id' })
+
 								if (!data[type][i]._id)
-									updateData = createUpdate({document: [data[type][i]]}, type)
+									updateData = createUpdate({ document: [data[type][i]] }, type)
 
-								data[type][i]['modified'] = {on: data.timeStamp, by: data.user_id || data.clientId}
+								data[type][i]['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
 
 							}
-							if (action =='deleteDocument') {
+							if (action == 'deleteDocument') {
 								if (data[type][i]._id) {
 									_ids.push(ObjectId(data[type][i]._id))
-									documents.push({_id: data[type][i]._id, db: 'mongodb', database, collection})
+									documents.push({ _id: data[type][i]._id, db: 'mongodb', database, collection })
 								}
 							}
 						}
 						if (_ids.length == 1)
 							query['_id'] = ObjectId(_ids[0])
 						else if (_ids.length > 0)
-							query['_id'] = {$in: _ids}
+							query['_id'] = { $in: _ids }
 					}
-					
+
 
 					if (action == 'createDocument') {
-						collectionObj.insertMany(data[type], function(error, result) {
+						collectionObj.insertMany(data[type], function (error, result) {
 							if (error)
 								errorHandler(data, error, database, collection)
-							
+
 							for (let i = 0; i < data[type].length; i++)
-								documents.push({db: 'mongodb', database, collection, ...data[type][i]})
+								documents.push({ db: 'mongodb', database, collection, ...data[type][i] })
 
-							collectionsLength -= 1           
+							collectionsLength -= 1
 							if (!collectionsLength)
 								databasesLength -= 1
-							
+
 							if (!databasesLength && !collectionsLength) {
 								data = createData(data, documents, type)
-								resolve(data)					
+								resolve(data)
 							}
-						});	
+						});
 					}
 
 					if (action == 'readDocument') {
@@ -356,7 +381,7 @@ function document(action, data){
 						if (data.filter) {
 							const count = await collectionObj.estimatedDocumentCount()
 							data.filter.count = count
-	
+
 							if (data.filter.startIndex)
 								index = data.filter.startIndex
 							if (data.filter.limit)
@@ -364,11 +389,11 @@ function document(action, data){
 							if (limit)
 								limit = index + limit;
 						}
-				
-						collectionObj.find(query).limit(limit).sort(sort).toArray(function(error, result) {
+
+						collectionObj.find(query).limit(limit).sort(sort).toArray(function (error, result) {
 							if (error)
 								errorHandler(data, error, database, collection)
-	
+
 							if (result) {
 								// ToDo: forEach at cursor
 								for (let doc of result) {
@@ -389,37 +414,37 @@ function document(action, data){
 								}
 
 								if (data.returnDocument == false) {
-									
-									for (let item of data['data'])  {
+
+									for (let item of data['data']) {
 										let resp = {};
 										resp['_id'] = tmp['_id']
 										data[type].forEach((f) => resp[f] = item[f])
 										documents.push(resp);
 									}
-		
+
 									data['data'] = documents
 								}
 							}
 
-							collectionsLength -= 1           
+							collectionsLength -= 1
 							if (!collectionsLength)
 								databasesLength -= 1
-							
+
 							if (!databasesLength && !collectionsLength) {
 								data = createData(data, documents, type)
-								resolve(data)					
+								resolve(data)
 							}
 						});
 					}
 
 					if (action == 'updateDocument' || action == 'deleteDocument') {
 						const queryDocs = () => {
-							return new Promise((resolve, reject) => {
-						
-								collectionObj.find(query).sort(sort).toArray(function(error, result) {
+							return new Promise(async (resolve, reject) => {
+
+								collectionObj.find(query).sort(sort).toArray(function (error, result) {
 									if (error)
 										errorHandler(data, error, database, collection)
-									
+
 									if (data.filter && data.filter.search) {
 										let searchResult = []
 
@@ -436,7 +461,7 @@ function document(action, data){
 								console.log(err);
 							});
 						}
-					
+
 						let Result, $update, update, projection;
 
 						if (isFilter && data.returnDocument != false)
@@ -446,44 +471,44 @@ function document(action, data){
 						if (Result) {
 							for (let doc of Result) {
 								if (action == 'deleteDocument')
-									documents.push({_id: doc._id, db: 'mongodb', database, collection})
+									documents.push({ _id: doc._id, db: 'mongodb', database, collection })
 								else
-									doc['modified'] = {on: data.timeStamp, by: data.user_id || data.clientId}
-								
+									doc['modified'] = { on: data.timeStamp, by: data.user_id || data.clientId }
+
 								_ids.push(doc._id)
 							}
-							update_ids.push({updateType: 'filter'})
+							update_ids.push({ updateType: 'filter' })
 						}
 
 						if (action == 'updateDocument') {
 							let docsLength = update_ids.length
-							for (let {updateDoc, updateType} of update_ids) {
-								
+							for (let { updateDoc, updateType } of update_ids) {
+
 								if (updateType == '_id') {
 									let update_id = updateDoc._id
 									query['_id'] = ObjectId(update_id)
-									$update = createUpdate({document: [updateDoc]}, type)
+									$update = createUpdate({ document: [updateDoc] }, type)
 									update = $update.update
 									projection = $update.projection
-									documents.push({_id: update_id, db: 'mongodb', database, collection, ...update['$set']})
+									documents.push({ _id: update_id, db: 'mongodb', database, collection, ...update['$set'] })
 								}
-								
+
 								if (updateType == 'filter') {
-									query['_id'] = {$in: _ids}
+									query['_id'] = { $in: _ids }
 									$update = updateData
 									update = $update.update
 									projection = $update.projection
 									for (let _id of _ids)
-										documents.push({_id, db: 'mongodb', database, collection, ...update['$set']})
+										documents.push({ _id, db: 'mongodb', database, collection, ...update['$set'] })
 
 								}
 
 								update['$set']['organization_id'] = data.organization_id
-								
+
 								collectionObj.updateMany(query, update, {
 									upsert: data.upsert,
 									projection
-								}).then((result) => {	
+								}).then((result) => {
 
 								}).catch((error) => {
 									errorHandler(data, error, database, collection)
@@ -491,29 +516,29 @@ function document(action, data){
 								}).finally((error) => {
 									docsLength -= 1
 									if (!docsLength)
-										collectionsLength -= 1  
+										collectionsLength -= 1
 
 									if (!collectionsLength)
 										databasesLength -= 1
-									
+
 									if (!databasesLength && !collectionsLength) {
 										data = createData(data, documents, type)
-										resolve(data)					
+										resolve(data)
 									}
 								})
-							} 
-							
+							}
+
 							if (!update_ids.length) {
 								docsLength -= 1
 								if (!docsLength)
-									collectionsLength -= 1  
+									collectionsLength -= 1
 
 								if (!collectionsLength)
 									databasesLength -= 1
-								
+
 								if (!databasesLength && !collectionsLength) {
 									data = createData(data, documents, type)
-									resolve(data)					
+									resolve(data)
 								}
 							}
 
@@ -523,26 +548,26 @@ function document(action, data){
 							if (_ids.length == 1)
 								query['_id'] = ObjectId(_ids[0])
 							else if (_ids.length > 0)
-								query['_id'] = {$in: _ids}
-							collectionObj.deleteMany(query, function(error, result) {
-								collectionsLength -= 1           
+								query['_id'] = { $in: _ids }
+							collectionObj.deleteMany(query, function (error, result) {
+								collectionsLength -= 1
 								if (!collectionsLength)
 									databasesLength -= 1
-								
+
 								if (!databasesLength && !collectionsLength) {
 									data = createData(data, documents, type)
-									resolve(data)					
+									resolve(data)
 								}
-								
+
 							})
 						}
 
 					}
-					
+
 				}
 			}
 
-		} catch(error) {
+		} catch (error) {
 			errorHandler(data, error)
 			console.log(action, 'error', error);
 			resolve(data);
@@ -555,7 +580,7 @@ function document(action, data){
 
 function createUpdate(data, type) {
 	let update = {}, projection = {};
-	if  (data[type][0]) {
+	if (data[type][0]) {
 		update['$set'] = data[type][0]
 		// update['$set']['organization_id'] = data['organization_id'];
 		if (update['$set']['_id'])
@@ -564,18 +589,18 @@ function createUpdate(data, type) {
 			projection[x] = 1
 		})
 	}
-		
-	if ( data['deleteName'] ) {
+
+	if (data['deleteName']) {
 		update['$unset'] = replaceArray(data['deleteName']);
 	}
-	
-	if ( data['updateName'] ) {
+
+	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 newValue = replaceArray({ [value]: value })
 				let oldkey = key;
 				for (const [key] of Object.entries(newValue)) {
 					update['$rename'][oldkey] = key
@@ -584,7 +609,7 @@ function createUpdate(data, type) {
 		}
 	}
 
-	return {update, projection}
+	return { update, projection }
 
 }
 
@@ -596,13 +621,13 @@ function createData(data, array, type) {
 		data[type] = sortData(array, data.filter.sort)
 	else
 		data[type] = array
-		
-	if (data.returnLog){
+
+	if (data.returnLog) {
 		if (!data.log)
 			data.log = []
 		data.log.push(...data[type])
 	}
-	
+
 	return data
 }
 
@@ -626,14 +651,14 @@ function getFilters(data) {
 		for (let i = 0; i < filter.sort.length; i++) {
 			let direction = filter.sort[i].direction
 			if (direction == 'desc' || direction == -1)
-				direction = -1;   
+				direction = -1;
 			else
 				direction = 1;
-	
+
 			sort[filter.sort[i].name] = filter.sort[i].direction
 		}
 	}
-	return {query, sort}
+	return { query, sort }
 }
 
 // ToDo: create impved mongodb query to cover many cases
@@ -645,9 +670,9 @@ function createQuery(filters) {
 
 		if (!item.name)
 			continue
-		
+
 		if (item.name == "_id") {
-			if (item.value) 
+			if (item.value)
 				item.value = ObjectId(item.value)
 			else
 				continue
@@ -657,23 +682,23 @@ function createQuery(filters) {
 		if (!query[key]) {
 			query[key] = {};
 		}
-	
+
 		switch (item.operator) {
 			case '$includes':
 			case 'includes':
 				query[key]['$regex'] = item.value;
 				break;
-				
+
 			case '$range':
 				if (item.value[0] !== null && item.value[1] !== null) {
-					query[key] = {$gte: item.value[0], $lte: item.value[1]};
+					query[key] = { $gte: item.value[0], $lte: item.value[1] };
 				} else if (item.value[0] !== null) {
-					query[key] = {$gte: item.value[0]};
+					query[key] = { $gte: item.value[0] };
 				} else if (item.value[1] !== null) {
-					query[key] = {$lte: item.value[1]};
+					query[key] = { $lte: item.value[1] };
 				}
 				break;
-				
+
 			case 'equals':
 				query[$eq][item.operator] = item.value;
 			case '$eq':
@@ -690,8 +715,8 @@ function createQuery(filters) {
 				// item.value.forEach(function(v) {
 				// 	in_values.push(new RegExp(".*" + v + ".*", "i"));
 				// });
-				
-				query[key] = {$in : item.value }
+
+				query[key] = { $in: item.value }
 				break;
 			case '$nin':
 				query[key][item.operator] = item.value;
@@ -702,13 +727,13 @@ function createQuery(filters) {
 					if (item.type) {
 						query[key]['$geoWithin'] = {
 							[item.type]: value
-						} 
+						}
 					}
-				} catch(e) {
+				} catch (e) {
 					console.log('geowithin error');
 				}
 				break;
-		}    
+		}
 	}
 
 	//. global search
@@ -720,11 +745,11 @@ function createQuery(filters) {
 	return query;
 }
 
-function errorHandler(data, error, database, collection){
+function errorHandler(data, error, database, collection) {
 	if (typeof error == 'object')
 		error['db'] = 'mongodb'
 	else
-		error = {db: 'mongodb', message: error}
+		error = { db: 'mongodb', message: error }
 
 	if (database)
 		error['database'] = database
@@ -735,41 +760,41 @@ function errorHandler(data, error, database, collection){
 	else
 		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.slice(0, -1)
 			nk = nk.replace(/\]./g, '.');
 			nk = nk.replace(/\]/g, '.');
 		}
-	  	objectData[nk] = data[k];
+		objectData[nk] = data[k];
 	});
-	
+
 	return objectData;
 }
 
 
 module.exports = {
 	databaseStats,
-    createDatabase,
-    readDatabase,
-    updateDatabase,
-    deleteDatabase,
-    
-    createCollection,
-    readCollection,
-    updateCollection,
-    deleteCollection, 
-
-    createDocument, 
-    readDocument,
-    updateDocument, 
-    deleteDocument, 
+	createDatabase,
+	readDatabase,
+	updateDatabase,
+	deleteDatabase,
+
+	createCollection,
+	readCollection,
+	updateCollection,
+	deleteCollection,
+
+	createDocument,
+	readDocument,
+	updateDocument,
+	deleteDocument,
 }