refactor: remove async.waterfall

src/upgrades/1.0.0/global_moderators.js

@@ -1,32 +1,22 @@
 'use strict';
 
-const async = require('async');
-
 module.exports = {
 	name: 'Creating Global moderators group',
 	timestamp: Date.UTC(2016, 0, 23),
-	method: function (callback) {
+	method: async function () {
 		const groups = require('../../groups');
-		async.waterfall([
+		const exists = await groups.exists('Global Moderators');
-			function (next) {
-				groups.exists('Global Moderators', next);
-			},
-			function (exists, next) {
 		if (exists) {
-					return next(null, null);
+			return;
 		}
-				groups.create({
+		await groups.create({
 			name: 'Global Moderators',
 			userTitle: 'Global Moderator',
 			description: 'Forum wide moderators',
 			hidden: 0,
 			private: 1,
 			disableJoinRequests: 1,
-				}, next);
+		});
-			},
+		await groups.show('Global Moderators');
-			function (groupData, next) {
-				groups.show('Global Moderators', next);
-			},
-		], callback);
 	},
 };

src/upgrades/1.0.0/theme_to_active_plugins.js

@@ -1,16 +1,13 @@
 'use strict';
 
-const async = require('async');
 const db = require('../../database');
 
 
 module.exports = {
 	name: 'Adding theme to active plugins sorted set',
 	timestamp: Date.UTC(2015, 11, 23),
-	method: function (callback) {
+	method: async function () {
-		async.waterfall([
+		const themeId = await db.getObjectField('config', 'theme:id');
-			async.apply(db.getObjectField, 'config', 'theme:id'),
+		await db.sortedSetAdd('plugins:active', 0, themeId);
-			async.apply(db.sortedSetAdd, 'plugins:active', 0),
-		], callback);
 	},
 };

src/upgrades/1.1.0/assign_topic_read_privilege.js

@@ -1,71 +1,35 @@
-'use strict';
+/* eslint-disable no-await-in-loop */
 
+'use strict';
 
-const async = require('async');
 const winston = require('winston');
 const db = require('../../database');
 
 module.exports = {
-	name: 'Giving topics:read privs to any group that was previously allowed to Find & Access Category',
+	name: 'Giving topics:read privs to any group/user that was previously allowed to Find & Access Category',
 	timestamp: Date.UTC(2016, 4, 28),
-	method: function (callback) {
+	method: async function () {
 		const groupsAPI = require('../../groups');
 		const privilegesAPI = require('../../privileges');
 
-		db.getSortedSetRange('categories:cid', 0, -1, (err, cids) => {
+		const cids = await db.getSortedSetRange('categories:cid', 0, -1);
-			if (err) {
+		for (const cid of cids) {
-				return callback(err);
+			const { groups, users } = await privilegesAPI.categories.list(cid);
-			}
-
-			async.eachSeries(cids, (cid, next) => {
-				privilegesAPI.categories.list(cid, (err, data) => {
-					if (err) {
-						return next(err);
-					}
-
-					const { groups } = data;
-					const { users } = data;
 
-					async.waterfall([
+			for (const group of groups) {
-						function (next) {
-							async.eachSeries(groups, (group, next) => {
 				if (group.privileges['groups:read']) {
-									return groupsAPI.join(`cid:${cid}:privileges:groups:topics:read`, group.name, (err) => {
+					await groupsAPI.join(`cid:${cid}:privileges:groups:topics:read`, group.name);
-										if (!err) {
 					winston.verbose(`cid:${cid}:privileges:groups:topics:read granted to gid: ${group.name}`);
 				}
-
-										return next(err);
-									});
 			}
 
-								next(null);
+			for (const user of users) {
-							}, next);
-						},
-						function (next) {
-							async.eachSeries(users, (user, next) => {
 				if (user.privileges.read) {
-									return groupsAPI.join(`cid:${cid}:privileges:topics:read`, user.uid, (err) => {
+					await groupsAPI.join(`cid:${cid}:privileges:topics:read`, user.uid);
-										if (!err) {
 					winston.verbose(`cid:${cid}:privileges:topics:read granted to uid: ${user.uid}`);
 				}
-
-										return next(err);
-									});
 			}
-
-								next(null);
-							}, next);
-						},
-					], (err) => {
-						if (!err) {
 			winston.verbose(`-- cid ${cid} upgraded`);
 		}
-
-						next(err);
-					});
-				});
-			}, callback);
-		});
 	},
 };

src/upgrades/1.1.0/dismiss_flags_from_deleted_topics.js

@@ -1,101 +1,56 @@
 'use strict';
 
 
-const async = require('async');
 const winston = require('winston');
 const db = require('../../database');
 
 module.exports = {
 	name: 'Dismiss flags from deleted topics',
 	timestamp: Date.UTC(2016, 3, 29),
-	method: function (callback) {
+	method: async function () {
 		const posts = require('../../posts');
 		const topics = require('../../topics');
 
-		let pids;
+		const pids = await db.getSortedSetRange('posts:flagged', 0, -1);
-		let tids;
+		const postData = await posts.getPostsFields(pids, ['tid']);
-
+		const tids = postData.map(t => t.tid);
-		async.waterfall([
+		const topicData = await topics.getTopicsFields(tids, ['deleted']);
-			async.apply(db.getSortedSetRange, 'posts:flagged', 0, -1),
+		const toDismiss = topicData.map((t, idx) => (parseInt(t.deleted, 10) === 1 ? pids[idx] : null)).filter(Boolean);
-			function (_pids, next) {
-				pids = _pids;
-				posts.getPostsFields(pids, ['tid'], next);
-			},
-			function (_tids, next) {
-				tids = _tids.map(a => a.tid);
-
-				topics.getTopicsFields(tids, ['deleted'], next);
-			},
-			function (state, next) {
-				const toDismiss = state.map((a, idx) => (parseInt(a.deleted, 10) === 1 ? pids[idx] : null)).filter(Boolean);
 
 		winston.verbose(`[2016/04/29] ${toDismiss.length} dismissable flags found`);
-				async.each(toDismiss, dismissFlag, next);
+		await Promise.all(toDismiss.map(dismissFlag));
-			},
-		], callback);
 	},
 };
 
 // copied from core since this function was removed
 // https://github.com/NodeBB/NodeBB/blob/v1.x.x/src/posts/flags.js
-function dismissFlag(pid, callback) {
+async function dismissFlag(pid) {
-	async.waterfall([
+	const postData = await db.getObjectFields(`post:${pid}`, ['pid', 'uid', 'flags']);
-		function (next) {
-			db.getObjectFields(`post:${pid}`, ['pid', 'uid', 'flags'], next);
-		},
-		function (postData, next) {
 	if (!postData.pid) {
-				return callback();
+		return;
 	}
-			async.parallel([
+	if (parseInt(postData.uid, 10) && parseInt(postData.flags, 10) > 0) {
-				function (next) {
+		await Promise.all([
-					if (parseInt(postData.uid, 10)) {
+			db.sortedSetIncrBy('users:flags', -postData.flags, postData.uid),
-						if (parseInt(postData.flags, 10) > 0) {
+			db.incrObjectFieldBy(`user:${postData.uid}`, 'flags', -postData.flags),
-							async.parallel([
+		]);
-								async.apply(db.sortedSetIncrBy, 'users:flags', -postData.flags, postData.uid),
-								async.apply(db.incrObjectFieldBy, `user:${postData.uid}`, 'flags', -postData.flags),
-							], next);
-						} else {
-							next();
 	}
-					} else {
+	const uids = await db.getSortedSetRange(`pid:${pid}:flag:uids`, 0, -1);
-						next();
+	const nids = uids.map(uid => `post_flag:${pid}:uid:${uid}`);
-					}
+
-				},
+	await Promise.all([
-				function (next) {
+		db.deleteAll(nids.map(nid => `notifications:${nid}`)),
+		db.sortedSetRemove('notifications', nids),
+		db.delete(`pid:${pid}:flag:uids`),
 		db.sortedSetsRemove([
 			'posts:flagged',
 			'posts:flags:count',
 			`uid:${postData.uid}:flag:pids`,
-					], pid, next);
+		], pid),
-				},
+		db.deleteObjectField(`post:${pid}`, 'flags'),
-				function (next) {
+		db.delete(`pid:${pid}:flag:uid:reason`),
-					async.series([
+		db.deleteObjectFields(`post:${pid}`, ['flag:state', 'flag:assignee', 'flag:notes', 'flag:history']),
-						function (next) {
+	]);
-							db.getSortedSetRange(`pid:${pid}:flag:uids`, 0, -1, (err, uids) => {
-								if (err) {
-									return next(err);
-								}
 
-								async.each(uids, (uid, next) => {
+	await db.sortedSetsRemoveRangeByScore(['users:flags'], '-inf', 0);
-									const nid = `post_flag:${pid}:uid:${uid}`;
-									async.parallel([
-										async.apply(db.delete, `notifications:${nid}`),
-										async.apply(db.sortedSetRemove, 'notifications', `post_flag:${pid}:uid:${uid}`),
-									], next);
-								}, next);
-							});
-						},
-						async.apply(db.delete, `pid:${pid}:flag:uids`),
-					], next);
-				},
-				async.apply(db.deleteObjectField, `post:${pid}`, 'flags'),
-				async.apply(db.delete, `pid:${pid}:flag:uid:reason`),
-				async.apply(db.deleteObjectFields, `post:${pid}`, ['flag:state', 'flag:assignee', 'flag:notes', 'flag:history']),
-			], next);
-		},
-		function (results, next) {
-			db.sortedSetsRemoveRangeByScore(['users:flags'], '-inf', 0, next);
-		},
-	], callback);
 }

src/upgrades/1.10.0/search_privileges.js

@@ -1,20 +1,15 @@
 'use strict';
 
-const async = require('async');
-
 module.exports = {
 	name: 'Give global search privileges',
 	timestamp: Date.UTC(2018, 4, 28),
-	method: function (callback) {
+	method: async function () {
 		const meta = require('../../meta');
 		const privileges = require('../../privileges');
 		const allowGuestSearching = parseInt(meta.config.allowGuestSearching, 10) === 1;
 		const allowGuestUserSearching = parseInt(meta.config.allowGuestUserSearching, 10) === 1;
-		async.waterfall([
+
-			function (next) {
+		await privileges.global.give(['groups:search:content', 'groups:search:users', 'groups:search:tags'], 'registered-users');
-				privileges.global.give(['groups:search:content', 'groups:search:users', 'groups:search:tags'], 'registered-users', next);
-			},
-			function (next) {
 		const guestPrivs = [];
 		if (allowGuestSearching) {
 			guestPrivs.push('groups:search:content');
@@ -23,8 +18,6 @@ module.exports = {
 			guestPrivs.push('groups:search:users');
 		}
 		guestPrivs.push('groups:search:tags');
-				privileges.global.give(guestPrivs, 'guests', next);
+		await privileges.global.give(guestPrivs, 'guests');
-			},
-		], callback);
 	},
 };