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,25 +60,13 @@ mongoModule.questions = [
 	},
 ];
 
-mongoModule.init = function (callback) {
+mongoModule.init = async function () {
-	callback = callback || function () { };
+	client = await connection.connect(nconf.get('mongo'));
-
-	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) {
-			return callback(err);
-		}
 	const meta = require('../meta');
 	const sessionStore = require('connect-mongo')(session);
 	const store = new sessionStore({
@@ -87,37 +74,25 @@ mongoModule.createSessionStore = function (options, callback) {
 		ttl: meta.getSessionTTLSeconds(),
 	});
 
-		callback(null, store);
+	return store;
-	});
 };
 
-mongoModule.createIndices = function (callback) {
+mongoModule.createIndices = async function () {
-	function createIndex(collection, index, options, callback) {
-		mongoModule.client.collection(collection).createIndex(index, options, callback);
-	}
-
 	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) {
-		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,37 +104,23 @@ 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);
 	}
-			connection.connect(nconf.get('mongo'), function (err, client) {
-				next(err, client ? client.db() : undefined);
-			});
-		},
-		function (db, next) {
 	mongoModule.client = mongoModule.client || db;
 
-			async.parallel({
+	let [serverStatus, stats, listCollections] = await Promise.all([
-				serverStatus: function (next) {
+		db.command({ serverStatus: 1 }),
-					db.command({ serverStatus: 1 }, next);
+		db.command({ dbStats: 1 }),
-				},
+		getCollectionStats(db),
-				stats: function (next) {
+	]);
-					db.command({ dbStats: 1 }, next);
+	stats = stats || {};
-				},
+	serverStatus = serverStatus || {};
-				listCollections: function (next) {
+	const scale = 1024 * 1024 * 1024;
-					getCollectionStats(db, next);
-				},
-			}, next);
-		},
-		function (results, next) {
-			var stats = results.stats || {};
-			results.serverStatus = results.serverStatus || {};
-			var scale = 1024 * 1024 * 1024;
 
-			results.listCollections = results.listCollections.map(function (collectionInfo) {
+	listCollections = listCollections.map(function (collectionInfo) {
 		return {
 			name: collectionInfo.ns,
 			count: collectionInfo.count,
@@ -171,12 +132,12 @@ mongoModule.info = function (db, callback) {
 		};
 	});
 
-			stats.mem = results.serverStatus.mem || {};
+	stats.mem = serverStatus.mem || {};
 	stats.mem.resident = (stats.mem.resident / 1024).toFixed(3);
 	stats.mem.virtual = (stats.mem.virtual / 1024).toFixed(3);
 	stats.mem.mapped = (stats.mem.mapped / 1024).toFixed(3);
-			stats.collectionData = results.listCollections;
+	stats.collectionData = listCollections;
-			stats.network = results.serverStatus.network || {};
+	stats.network = serverStatus.network || {};
 	stats.network.bytesIn = (stats.network.bytesIn / scale).toFixed(3);
 	stats.network.bytesOut = (stats.network.bytesOut / scale).toFixed(3);
 	stats.network.numRequests = utils.addCommas(stats.network.numRequests);
@@ -187,39 +148,26 @@ mongoModule.info = function (db, callback) {
 	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.storageEngine = serverStatus.storageEngine ? serverStatus.storageEngine.name : 'mmapv1';
-			stats.host = results.serverStatus.host;
+	stats.host = serverStatus.host;
-			stats.version = results.serverStatus.version;
+	stats.version = serverStatus.version;
-			stats.uptime = results.serverStatus.uptime;
+	stats.uptime = serverStatus.uptime;
 	stats.mongo = true;
-
+	return stats;
-			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);
 };