refactor: remove async.waterfall

src/upgrades/1.11.0/resize_image_width.js

@@ -1,24 +1,14 @@
 'use strict';
 
-const async = require('async');
 const db = require('../../database');
 
-
 module.exports = {
 	name: 'Rename maximumImageWidth to resizeImageWidth',
 	timestamp: Date.UTC(2018, 9, 24),
-	method: function (callback) {
+	method: async function () {
 		const meta = require('../../meta');
-		async.waterfall([
+		const value = await meta.configs.get('maximumImageWidth');
-			function (next) {
+		await meta.configs.set('resizeImageWidth', value);
-				meta.configs.get('maximumImageWidth', next);
+		await db.deleteObjectField('config', 'maximumImageWidth');
-			},
-			function (value, next) {
-				meta.configs.set('resizeImageWidth', value, next);
-			},
-			function (next) {
-				db.deleteObjectField('config', 'maximumImageWidth', next);
-			},
-		], callback);
 	},
 };

src/upgrades/1.11.0/widget_visibility_groups.js

@@ -1,19 +1,13 @@
 'use strict';
 
-const async = require('async');
-
 module.exports = {
 	name: 'Widget visibility groups',
 	timestamp: Date.UTC(2018, 10, 10),
-	method: function (callback) {
+	method: async function () {
 		const widgetAdmin = require('../../widgets/admin');
 		const widgets = require('../../widgets');
-		async.waterfall([
+		const areas = await widgetAdmin.getAreas();
-			function (next) {
+		for (const area of areas) {
-				widgetAdmin.getAreas(next);
-			},
-			function (areas, next) {
-				async.eachSeries(areas, (area, next) => {
 			if (area.data.length) {
 				// area.data is actually an array of widgets
 				area.widgets = area.data;
@@ -36,12 +30,9 @@ module.exports = {
 						}
 					}
 				});
-						widgets.setArea(area, next);
+				// eslint-disable-next-line no-await-in-loop
-					} else {
+				await widgets.setArea(area);
-						next();
+			}
 		}
-				}, next);
-			},
-		], callback);
 	},
 };

src/upgrades/1.12.0/category_watch_state.js

@@ -1,6 +1,6 @@
-'use strict';
+/* eslint-disable no-await-in-loop */
 
-const async = require('async');
+'use strict';
 
 const db = require('../../database');
 const batch = require('../../batch');
@@ -9,39 +9,27 @@ const categories = require('../../categories');
 module.exports = {
 	name: 'Update category watch data',
 	timestamp: Date.UTC(2018, 11, 13),
-	method: function (callback) {
+	method: async function () {
 		const { progress } = this;
-		let keys;
-		async.waterfall([
-			function (next) {
-				db.getSortedSetRange('categories:cid', 0, -1, next);
-			},
-			function (cids, next) {
-				keys = cids.map(cid => `cid:${cid}:ignorers`);
-				batch.processSortedSet('users:joindate', (uids, next) => {
-					progress.incr(uids.length);
 
-					async.eachSeries(cids, (cid, next) => {
+		const cids = await db.getSortedSetRange('categories:cid', 0, -1);
-						db.isSortedSetMembers(`cid:${cid}:ignorers`, uids, (err, isMembers) => {
+		const keys = cids.map(cid => `cid:${cid}:ignorers`);
-							if (err) {
+
-								return next(err);
+		await batch.processSortedSet('users:joindate', async (uids) => {
-							}
+			progress.incr(uids.length);
+			for (const cid of cids) {
+				const isMembers = await db.isSortedSetMembers(`cid:${cid}:ignorers`, uids);
 				uids = uids.filter((uid, index) => isMembers[index]);
-							if (!uids.length) {
+				if (uids.length) {
-								return setImmediate(next);
-							}
 					const states = uids.map(() => categories.watchStates.ignoring);
-							db.sortedSetAdd(`cid:${cid}:uid:watch:state`, states, uids, next);
+					await db.sortedSetAdd(`cid:${cid}:uid:watch:state`, states, uids);
-						});
+				}
-					}, next);
+			}
 		}, {
 			progress: progress,
 			batch: 500,
-				}, next);
+		});
-			},
+
-			function (next) {
+		await db.deleteAll(keys);
-				db.deleteAll(keys, next);
-			},
-		], callback);
 	},
 };

src/upgrades/1.12.1/moderation_notes_refactor.js

@@ -1,55 +1,35 @@
+/* eslint-disable no-await-in-loop */
+
 'use strict';
 
-const async = require('async');
 const db = require('../../database');
 const batch = require('../../batch');
 
-
 module.exports = {
 	name: 'Update moderation notes to hashes',
 	timestamp: Date.UTC(2019, 3, 5),
-	method: function (callback) {
+	method: async function () {
 		const { progress } = this;
 
-		batch.processSortedSet('users:joindate', (ids, next) => {
+		await batch.processSortedSet('users:joindate', async (uids) => {
-			async.each(ids, (uid, next) => {
+			await Promise.all(uids.map(async (uid) => {
 				progress.incr();
-				db.getSortedSetRevRange(`uid:${uid}:moderation:notes`, 0, -1, (err, notes) => {
-					if (err || !notes.length) {
-						return next(err);
-					}
 
-					async.eachSeries(notes, (note, next) => {
+				const notes = await db.getSortedSetRevRange(`uid:${uid}:moderation:notes`, 0, -1);
-						let noteData;
+				for (const note of notes) {
-						async.waterfall([
+					const noteData = JSON.parse(note);
-							function (next) {
-								try {
-									noteData = JSON.parse(note);
 					noteData.timestamp = noteData.timestamp || Date.now();
-									setImmediate(next);
+					await db.sortedSetRemove(`uid:${uid}:moderation:notes`, note);
-								} catch (err) {
+					await db.setObject(`uid:${uid}:moderation:note:${noteData.timestamp}`, {
-									next(err);
-								}
-							},
-							function (next) {
-								db.sortedSetRemove(`uid:${uid}:moderation:notes`, note, next);
-							},
-							function (next) {
-								db.setObject(`uid:${uid}:moderation:note:${noteData.timestamp}`, {
 						uid: noteData.uid,
 						timestamp: noteData.timestamp,
 						note: noteData.note,
-								}, next);
-							},
-							function (next) {
-								db.sortedSetAdd(`uid:${uid}:moderation:notes`, noteData.timestamp, noteData.timestamp, next);
-							},
-						], next);
-					}, next);
 					});
-			}, next);
+					await db.sortedSetAdd(`uid:${uid}:moderation:notes`, noteData.timestamp, noteData.timestamp);
+				}
+			}));
 		}, {
 			progress: this.progress,
-		}, callback);
+		});
 	},
 };

src/upgrades/1.12.3/give_mod_info_privilege.js

@@ -1,6 +1,7 @@
+/* eslint-disable no-await-in-loop */
+
 'use strict';
 
-const async = require('async');
 const db = require('../../database');
 const privileges = require('../../privileges');
 const groups = require('../../groups');
@@ -8,38 +9,19 @@ const groups = require('../../groups');
 module.exports = {
 	name: 'give mod info privilege',
 	timestamp: Date.UTC(2019, 9, 8),
-	method: function (callback) {
+	method: async function () {
-		async.waterfall([
+		const cids = await db.getSortedSetRevRange('categories:cid', 0, -1);
-			function (next) {
+		for (const cid of cids) {
-				db.getSortedSetRevRange('categories:cid', 0, -1, next);
+			await givePrivsToModerators(cid, '');
-			},
+			await givePrivsToModerators(cid, 'groups:');
-			function (cids, next) {
+		}
-				async.eachSeries(cids, (cid, next) => {
+		await privileges.global.give(['groups:view:users:info'], 'Global Moderators');
-					async.waterfall([
+
-						function (next) {
+		async function givePrivsToModerators(cid, groupPrefix) {
-							givePrivsToModerators(cid, '', next);
+			const members = await db.getSortedSetRevRange(`group:cid:${cid}:privileges:${groupPrefix}moderate:members`, 0, -1);
-						},
+			for (const member of members) {
-						function (next) {
+				await groups.join(['cid:0:privileges:view:users:info'], member);
-							givePrivsToModerators(cid, 'groups:', next);
+			}
-						},
-					], next);
-				}, next);
-			},
-			function (next) {
-				privileges.global.give(['groups:view:users:info'], 'Global Moderators', next);
-			},
-		], callback);
-		function givePrivsToModerators(cid, groupPrefix, callback) {
-			async.waterfall([
-				function (next) {
-					db.getSortedSetRevRange(`group:cid:${cid}:privileges:${groupPrefix}moderate:members`, 0, -1, next);
-				},
-				function (members, next) {
-					async.eachSeries(members, (member, next) => {
-						groups.join(['cid:0:privileges:view:users:info'], member, next);
-					}, next);
-				},
-			], callback);
 		}
 	},
 };

src/upgrades/1.12.3/give_mod_privileges.js

@@ -1,6 +1,7 @@
+/* eslint-disable no-await-in-loop */
+
 'use strict';
 
-const async = require('async');
 const privileges = require('../../privileges');
 const groups = require('../../groups');
 const db = require('../../database');
@@ -8,7 +9,7 @@ const db = require('../../database');
 module.exports = {
 	name: 'Give mods explicit privileges',
 	timestamp: Date.UTC(2019, 4, 28),
-	method: function (callback) {
+	method: async function () {
 		const defaultPrivileges = [
 			'find',
 			'read',
@@ -43,43 +44,20 @@ module.exports = {
 			'groups:local:login',
 		];
 
-		async.waterfall([
+		const cids = await db.getSortedSetRevRange('categories:cid', 0, -1);
-			function (next) {
+		for (const cid of cids) {
-				db.getSortedSetRevRange('categories:cid', 0, -1, next);
+			await givePrivsToModerators(cid, '');
-			},
+			await givePrivsToModerators(cid, 'groups:');
-			function (cids, next) {
+			await privileges.categories.give(modPrivileges.map(p => `groups:${p}`), cid, ['Global Moderators']);
-				async.eachSeries(cids, (cid, next) => {
+		}
-					async.waterfall([
+		await privileges.global.give(globalModPrivs, 'Global Moderators');
-						function (next) {
-							givePrivsToModerators(cid, '', next);
-						},
-						function (next) {
-							givePrivsToModerators(cid, 'groups:', next);
-						},
-						function (next) {
-							privileges.categories.give(modPrivileges.map(p => `groups:${p}`), cid, ['Global Moderators'], next);
-						},
-					], next);
-				}, next);
-			},
-			function (next) {
-				privileges.global.give(globalModPrivs, 'Global Moderators', next);
-			},
-		], callback);
 
-		function givePrivsToModerators(cid, groupPrefix, callback) {
+		async function givePrivsToModerators(cid, groupPrefix) {
 			const privGroups = modPrivileges.map(priv => `cid:${cid}:privileges:${groupPrefix}${priv}`);
-
+			const members = await db.getSortedSetRevRange(`group:cid:${cid}:privileges:${groupPrefix}moderate:members`, 0, -1);
-			async.waterfall([
+			for (const member of members) {
-				function (next) {
+				await groups.join(privGroups, member);
-					db.getSortedSetRevRange(`group:cid:${cid}:privileges:${groupPrefix}moderate:members`, 0, -1, next);
+			}
-				},
-				function (members, next) {
-					async.eachSeries(members, (member, next) => {
-						groups.join(privGroups, member, next);
-					}, next);
-				},
-			], callback);
 		}
 	},
 };

src/upgrades/1.12.3/user_pid_sets.js

@@ -1,6 +1,6 @@
+
 'use strict';
 
-const async = require('async');
 
 const db = require('../../database');
 const batch = require('../../batch');
@@ -10,22 +10,14 @@ const topics = require('../../topics');
 module.exports = {
 	name: 'Create zsets for user posts per category',
 	timestamp: Date.UTC(2019, 5, 23),
-	method: function (callback) {
+	method: async function () {
 		const { progress } = this;
 
-		batch.processSortedSet('posts:pid', (pids, next) => {
+		await batch.processSortedSet('posts:pid', async (pids) => {
 			progress.incr(pids.length);
-			let postData;
+			const postData = await posts.getPostsFields(pids, ['pid', 'uid', 'tid', 'upvotes', 'downvotes', 'timestamp']);
-			async.waterfall([
-				function (next) {
-					posts.getPostsFields(pids, ['pid', 'uid', 'tid', 'upvotes', 'downvotes', 'timestamp'], next);
-				},
-				function (_postData, next) {
-					postData = _postData;
 			const tids = postData.map(p => p.tid);
-					topics.getTopicsFields(tids, ['cid'], next);
+			const topicData = await topics.getTopicsFields(tids, ['cid']);
-				},
-				function (topicData, next) {
 			const bulk = [];
 			postData.forEach((p, index) => {
 				if (p && p.uid && p.pid && p.tid && p.timestamp) {
@@ -35,11 +27,9 @@ module.exports = {
 					}
 				}
 			});
-					db.sortedSetAddBulk(bulk, next);
+			await db.sortedSetAddBulk(bulk);
-				},
-			], next);
 		}, {
 			progress: progress,
-		}, callback);
+		});
 	},
 };