refactor: async/await mongo

src/database/mongo.js

@@ -3,7 +3,6 @@
 
 
 const winston = require('winston');
-const async = require('async');
 const nconf = require('nconf');
 const session = require('express-session');
 const semver = require('semver');
@@ -61,63 +60,39 @@ mongoModule.questions = [
 	},
 ];
 
-mongoModule.init = function (callback) {
+mongoModule.init = async function () {
-	callback = callback || function () { };
+	client = await connection.connect(nconf.get('mongo'));
-
+	mongoModule.client = client.db();
-	connection.connect(nconf.get('mongo'), function (err, _client) {
-		if (err) {
-			winston.error('NodeBB could not connect to your Mongo database. Mongo returned the following error', err);
-			return callback(err);
-		}
-		client = _client;
-		mongoModule.client = client.db();
-		callback();
-	});
 };
 
-mongoModule.createSessionStore = function (options, callback) {
+mongoModule.createSessionStore = async function (options) {
-	connection.connect(options, function (err, client) {
+	const client = await connection.connect(options);
-		if (err) {
+	const meta = require('../meta');
-			return callback(err);
+	const sessionStore = require('connect-mongo')(session);
-		}
+	const store = new sessionStore({
-		const meta = require('../meta');
+		client: client,
-		const sessionStore = require('connect-mongo')(session);
+		ttl: meta.getSessionTTLSeconds(),
-		const store = new sessionStore({
-			client: client,
-			ttl: meta.getSessionTTLSeconds(),
-		});
-
-		callback(null, store);
 	});
-};
 
-mongoModule.createIndices = function (callback) {
+	return store;
-	function createIndex(collection, index, options, callback) {
+};
-		mongoModule.client.collection(collection).createIndex(index, options, callback);
-	}
 
+mongoModule.createIndices = async function () {
 	if (!mongoModule.client) {
 		winston.warn('[database/createIndices] database not initialized');
-		return callback();
+		return;
 	}
 
 	winston.info('[database] Checking database indices.');
-	async.series([
+	const collection = mongoModule.client.collection('objects');
-		async.apply(createIndex, 'objects', { _key: 1, score: -1 }, { background: true }),
+	await collection.createIndex({ _key: 1, score: -1 }, { background: true });
-		async.apply(createIndex, 'objects', { _key: 1, value: -1 }, { background: true, unique: true, sparse: true }),
+	await collection.createIndex({ _key: 1, value: -1 }, { background: true, unique: true, sparse: true });
-		async.apply(createIndex, 'objects', { expireAt: 1 }, { expireAfterSeconds: 0, background: true }),
+	await collection.createIndex({ expireAt: 1 }, { expireAfterSeconds: 0, background: true });
-	], function (err) {
+	winston.info('[database] Checking database indices done!');
-		if (err) {
-			winston.error('Error creating index', err);
-			return callback(err);
-		}
-		winston.info('[database] Checking database indices done!');
-		callback();
-	});
 };
 
 mongoModule.checkCompatibility = function (callback) {
-	var mongoPkg = require('mongodb/package.json');
+	const mongoPkg = require('mongodb/package.json');
 	mongoModule.checkCompatibilityVersion(mongoPkg.version, callback);
 };
 
@@ -129,97 +104,70 @@ mongoModule.checkCompatibilityVersion = function (version, callback) {
 	callback();
 };
 
-mongoModule.info = function (db, callback) {
+mongoModule.info = async function (db) {
-	async.waterfall([
+	if (!db) {
-		function (next) {
+		const client = await connection.connect(nconf.get('mongo'));
-			if (db) {
+		db = client.db();
-				return setImmediate(next, null, db);
+	}
-			}
+	mongoModule.client = mongoModule.client || db;
-			connection.connect(nconf.get('mongo'), function (err, client) {
+
-				next(err, client ? client.db() : undefined);
+	let [serverStatus, stats, listCollections] = await Promise.all([
-			});
+		db.command({ serverStatus: 1 }),
-		},
+		db.command({ dbStats: 1 }),
-		function (db, next) {
+		getCollectionStats(db),
-			mongoModule.client = mongoModule.client || db;
+	]);
-
+	stats = stats || {};
-			async.parallel({
+	serverStatus = serverStatus || {};
-				serverStatus: function (next) {
+	const scale = 1024 * 1024 * 1024;
-					db.command({ serverStatus: 1 }, next);
+
-				},
+	listCollections = listCollections.map(function (collectionInfo) {
-				stats: function (next) {
+		return {
-					db.command({ dbStats: 1 }, next);
+			name: collectionInfo.ns,
-				},
+			count: collectionInfo.count,
-				listCollections: function (next) {
+			size: collectionInfo.size,
-					getCollectionStats(db, next);
+			avgObjSize: collectionInfo.avgObjSize,
-				},
+			storageSize: collectionInfo.storageSize,
-			}, next);
+			totalIndexSize: collectionInfo.totalIndexSize,
-		},
+			indexSizes: collectionInfo.indexSizes,
-		function (results, next) {
+		};
-			var stats = results.stats || {};
+	});
-			results.serverStatus = results.serverStatus || {};
+
-			var scale = 1024 * 1024 * 1024;
+	stats.mem = serverStatus.mem || {};
-
+	stats.mem.resident = (stats.mem.resident / 1024).toFixed(3);
-			results.listCollections = results.listCollections.map(function (collectionInfo) {
+	stats.mem.virtual = (stats.mem.virtual / 1024).toFixed(3);
-				return {
+	stats.mem.mapped = (stats.mem.mapped / 1024).toFixed(3);
-					name: collectionInfo.ns,
+	stats.collectionData = listCollections;
-					count: collectionInfo.count,
+	stats.network = serverStatus.network || {};
-					size: collectionInfo.size,
+	stats.network.bytesIn = (stats.network.bytesIn / scale).toFixed(3);
-					avgObjSize: collectionInfo.avgObjSize,
+	stats.network.bytesOut = (stats.network.bytesOut / scale).toFixed(3);
-					storageSize: collectionInfo.storageSize,
+	stats.network.numRequests = utils.addCommas(stats.network.numRequests);
-					totalIndexSize: collectionInfo.totalIndexSize,
+	stats.raw = JSON.stringify(stats, null, 4);
-					indexSizes: collectionInfo.indexSizes,
+
-				};
+	stats.avgObjSize = stats.avgObjSize.toFixed(2);
-			});
+	stats.dataSize = (stats.dataSize / scale).toFixed(3);
-
+	stats.storageSize = (stats.storageSize / scale).toFixed(3);
-			stats.mem = results.serverStatus.mem || {};
+	stats.fileSize = stats.fileSize ? (stats.fileSize / scale).toFixed(3) : 0;
-			stats.mem.resident = (stats.mem.resident / 1024).toFixed(3);
+	stats.indexSize = (stats.indexSize / scale).toFixed(3);
-			stats.mem.virtual = (stats.mem.virtual / 1024).toFixed(3);
+	stats.storageEngine = serverStatus.storageEngine ? serverStatus.storageEngine.name : 'mmapv1';
-			stats.mem.mapped = (stats.mem.mapped / 1024).toFixed(3);
+	stats.host = serverStatus.host;
-			stats.collectionData = results.listCollections;
+	stats.version = serverStatus.version;
-			stats.network = results.serverStatus.network || {};
+	stats.uptime = serverStatus.uptime;
-			stats.network.bytesIn = (stats.network.bytesIn / scale).toFixed(3);
+	stats.mongo = true;
-			stats.network.bytesOut = (stats.network.bytesOut / scale).toFixed(3);
+	return stats;
-			stats.network.numRequests = utils.addCommas(stats.network.numRequests);
-			stats.raw = JSON.stringify(stats, null, 4);
-
-			stats.avgObjSize = stats.avgObjSize.toFixed(2);
-			stats.dataSize = (stats.dataSize / scale).toFixed(3);
-			stats.storageSize = (stats.storageSize / scale).toFixed(3);
-			stats.fileSize = stats.fileSize ? (stats.fileSize / scale).toFixed(3) : 0;
-			stats.indexSize = (stats.indexSize / scale).toFixed(3);
-			stats.storageEngine = results.serverStatus.storageEngine ? results.serverStatus.storageEngine.name : 'mmapv1';
-			stats.host = results.serverStatus.host;
-			stats.version = results.serverStatus.version;
-			stats.uptime = results.serverStatus.uptime;
-			stats.mongo = true;
-
-			next(null, stats);
-		},
-	], callback);
 };
 
-function getCollectionStats(db, callback) {
+async function getCollectionStats(db) {
-	async.waterfall([
+	const items = await db.listCollections().toArray();
-		function (next) {
+	return await Promise.all(items.map(collection => db.collection(collection.name).stats));
-			db.listCollections().toArray(next);
-		},
-		function (items, next) {
-			async.map(items, function (collection, next) {
-				db.collection(collection.name).stats(next);
-			}, next);
-		},
-	], callback);
 }
 
 mongoModule.close = function (callback) {
 	callback = callback || function () {};
-	client.close(function (err) {
+	client.close(err => callback(err));
-		callback(err);
-	});
 };
 
 mongoModule.socketAdapter = function () {
-	var mongoAdapter = require('socket.io-adapter-mongo');
+	const mongoAdapter = require('socket.io-adapter-mongo');
 	return mongoAdapter(connection.getConnectionString());
 };
 

src/database/mongo/connection.js

@@ -56,13 +56,11 @@ connection.getConnectionOptions = function (mongo) {
 	return _.merge(connOptions, mongo.options || {});
 };
 
-connection.connect = function (options, callback) {
+connection.connect = async function (options) {
-	callback = callback || function () { };
-
 	const mongoClient = require('mongodb').MongoClient;
 
 	const connString = connection.getConnectionString(options);
 	const connOptions = connection.getConnectionOptions(options);
 
-	mongoClient.connect(connString, connOptions, callback);
+	return await mongoClient.connect(connString, connOptions);
 };