Async refactor in place (#7736)

* feat: allow both callback&and await

* feat: ignore async key

* feat: callbackify and promisify in same file

* Revert "feat: callbackify and promisify in same file"

This reverts commit cea206a9b8.

* feat: no need to store .callbackify

* feat: change getTopics to async

* feat: remove .async

* fix: byScore

* feat: rewrite topics/index and social with async/await

* fix: rewrite topics/data.js

fix issue with async.waterfall, only pass result if its not undefined

* feat: add callbackify to redis/psql

* feat: psql use await

* fix: redis 🌋

* feat: less returns

* feat: more await rewrite

* fix: redis tests

* feat: convert sortedSetAdd

rewrite psql transaction to async/await

* feat: 🐶

* feat: test

* feat: log client and query

* feat: log bind

* feat: more logs

* feat: more logs

* feat: check perform

* feat: dont callbackify transaction

* feat: remove logs

* fix: main functions

* feat: more logs

* fix: increment

* fix: rename

* feat: remove cls

* fix: remove console.log

* feat: add deprecation message to .async usage

* feat: update more dbal methods

* fix: redis :voodoo:

* feat:  fix redis zrem, convert setObject

* feat: upgrade getObject methods

* fix: psql getObjectField

* fix: redis tests

* feat: getObjectKeys

* feat: getObjectValues

* feat: isObjectField

* fix: add missing return

* feat: delObjectField

* feat: incrObjectField

* fix: add missing await

* feat: remove exposed helpers

* feat: list methods

* feat: flush/empty

* feat: delete

* fix: redis delete all

* feat: get/set

* feat: incr/rename

* feat: type

* feat: expire

* feat: setAdd

* feat: setRemove

* feat: isSetMember

* feat: getSetMembers

* feat: setCount, setRemoveRandom

* feat: zcard,zcount

* feat: sortedSetRank

* feat: isSortedSetMember

* feat: zincrby

* feat: sortedSetLex

* feat: processSortedSet

* fix: add mising await

* feat: debug psql

* fix: psql test

* fix: test

* fix: another test

* fix: test fix

* fix: psql tests

* feat: remove logs

* feat: user arrow func

use builtin async promises

* feat: topic bookmarks

* feat: topic.delete

* feat: topic.restore

* feat: topics.purge

* feat: merge

* feat: suggested

* feat: topics/user.js

* feat: topics modules

* feat: topics/follow

* fix: deprecation msg

* feat: fork

* feat: topics/posts

* feat: sorted/recent

* feat: topic/teaser

* feat: topics/tools

* feat: topics/unread

* feat: add back node versions

disable deprecation notice
wrap async controllers in try/catch

* feat: use db directly

* feat: promisify in place

* fix: redis/psql

* feat: deprecation message

logs for psql

* feat: more logs

* feat: more logs

* feat: logs again

* feat: more logs

* fix: call release

* feat: restore travis, remove logs

* fix: loops

* feat: remove .async. usage

src/database/redis/sorted/add.js

@@ -1,83 +1,72 @@
 'use strict';
 
 module.exports = function (redisClient, module) {
+	const helpers = require('../helpers');
 	const utils = require('../../../utils');
 
-	module.sortedSetAdd = function (key, score, value, callback) {
-		callback = callback || function () {};
+	module.sortedSetAdd = async function (key, score, value) {
 		if (!key) {
-			return setImmediate(callback);
+			return;
 		}
 		if (Array.isArray(score) && Array.isArray(value)) {
-			return sortedSetAddMulti(key, score, value, callback);
+			return await sortedSetAddMulti(key, score, value);
 		}
 		if (!utils.isNumber(score)) {
-			return setImmediate(callback, new Error('[[error:invalid-score, ' + score + ']]'));
+			throw new Error('[[error:invalid-score, ' + score + ']]');
 		}
-		redisClient.zadd(key, score, String(value), function (err) {
-			callback(err);
-		});
+		await redisClient.async.zadd(key, score, String(value));
 	};
 
-	function sortedSetAddMulti(key, scores, values, callback) {
+	async function sortedSetAddMulti(key, scores, values) {
 		if (!scores.length || !values.length) {
-			return callback();
+			return;
 		}
 
 		if (scores.length !== values.length) {
-			return callback(new Error('[[error:invalid-data]]'));
+			throw new Error('[[error:invalid-data]]');
 		}
 		for (let i = 0; i < scores.length; i += 1) {
 			if (!utils.isNumber(scores[i])) {
-				return setImmediate(callback, new Error('[[error:invalid-score, ' + scores[i] + ']]'));
+				throw new Error('[[error:invalid-score, ' + scores[i] + ']]');
 			}
 		}
 		var args = [key];
-
 		for (var i = 0; i < scores.length; i += 1) {
 			args.push(scores[i], String(values[i]));
 		}
-
-		redisClient.zadd(args, function (err) {
-			callback(err);
-		});
+		await redisClient.async.zadd(args);
 	}
 
-	module.sortedSetsAdd = function (keys, scores, value, callback) {
-		callback = callback || function () {};
+	module.sortedSetsAdd = async function (keys, scores, value) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return setImmediate(callback);
+			return;
 		}
 		const isArrayOfScores = Array.isArray(scores);
 		if (!isArrayOfScores && !utils.isNumber(scores)) {
-			return setImmediate(callback, new Error('[[error:invalid-score, ' + scores + ']]'));
+			throw new Error('[[error:invalid-score, ' + scores + ']]');
 		}
 
 		if (isArrayOfScores && scores.length !== keys.length) {
-			return setImmediate(callback, new Error('[[error:invalid-data]]'));
+			throw new Error('[[error:invalid-data]]');
 		}
 
 		var batch = redisClient.batch();
-
 		for (var i = 0; i < keys.length; i += 1) {
 			if (keys[i]) {
 				batch.zadd(keys[i], isArrayOfScores ? scores[i] : scores, String(value));
 			}
 		}
-
-		batch.exec(function (err) {
-			callback(err);
-		});
+		await helpers.execBatch(batch);
 	};
 
-	module.sortedSetAddBulk = function (data, callback) {
+	module.sortedSetAddBulk = async function (data) {
 		if (!Array.isArray(data) || !data.length) {
-			return setImmediate(callback);
+			return;
 		}
 		var batch = redisClient.batch();
 		data.forEach(function (item) {
 			batch.zadd(item[0], item[1], item[2]);
 		});
-		batch.exec(err => callback(err));
+		await helpers.execBatch(batch);
 	};
 };

src/database/redis/sorted/intersect.js

@@ -2,9 +2,10 @@
 'use strict';
 
 module.exports = function (redisClient, module) {
-	module.sortedSetIntersectCard = function (keys, callback) {
+	const helpers = require('../helpers');
+	module.sortedSetIntersectCard = async function (keys) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, 0);
+			return 0;
 		}
 		var tempSetName = 'temp_' + Date.now();
 
@@ -14,26 +15,21 @@ module.exports = function (redisClient, module) {
 		multi.zinterstore(interParams);
 		multi.zcard(tempSetName);
 		multi.del(tempSetName);
-		multi.exec(function (err, results) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, results[1] || 0);
-		});
+		const results = await helpers.execBatch(multi);
+		return results[1] || 0;
 	};
 
-	module.getSortedSetIntersect = function (params, callback) {
+	module.getSortedSetIntersect = async function (params) {
 		params.method = 'zrange';
-		getSortedSetRevIntersect(params, callback);
+		return await getSortedSetRevIntersect(params);
 	};
 
-	module.getSortedSetRevIntersect = function (params, callback) {
+	module.getSortedSetRevIntersect = async function (params) {
 		params.method = 'zrevrange';
-		getSortedSetRevIntersect(params, callback);
+		return await getSortedSetRevIntersect(params);
 	};
 
-	function getSortedSetRevIntersect(params, callback) {
+	async function getSortedSetRevIntersect(params) {
 		var sets = params.sets;
 		var start = params.hasOwnProperty('start') ? params.start : 0;
 		var stop = params.hasOwnProperty('stop') ? params.stop : -1;
@@ -59,20 +55,16 @@ module.exports = function (redisClient, module) {
 		multi.zinterstore(interParams);
 		multi[params.method](rangeParams);
 		multi.del(tempSetName);
-		multi.exec(function (err, results) {
-			if (err) {
-				return callback(err);
-			}
+		let results = await helpers.execBatch(multi);
 
-			if (!params.withScores) {
-				return callback(null, results ? results[1] : null);
-			}
-			results = results[1] || [];
-			var objects = [];
-			for (var i = 0; i < results.length; i += 2) {
-				objects.push({ value: results[i], score: parseFloat(results[i + 1]) });
-			}
-			callback(null, objects);
-		});
+		if (!params.withScores) {
+			return results ? results[1] : null;
+		}
+		results = results[1] || [];
+		var objects = [];
+		for (var i = 0; i < results.length; i += 2) {
+			objects.push({ value: results[i], score: parseFloat(results[i + 1]) });
+		}
+		return objects;
 	}
 };

src/database/redis/sorted/remove.js

@@ -2,46 +2,36 @@
 'use strict';
 
 module.exports = function (redisClient, module) {
-	var helpers = module.helpers.redis;
+	var helpers = require('../helpers');
 
-	module.sortedSetRemove = function (key, value, callback) {
-		callback = callback || function () {};
-		if (!value) {
-			return callback();
+	module.sortedSetRemove = async function (key, value) {
+		if (!key) {
+			return;
 		}
-		if (!Array.isArray(value)) {
+		const isValueArray = Array.isArray(value);
+		if (!value || (isValueArray && !value.length)) {
+			return;
+		}
+		if (!isValueArray) {
 			value = [value];
 		}
 
 		if (Array.isArray(key)) {
-			var batch = redisClient.batch();
-			key.forEach(function (key) {
-				batch.zrem(key, value);
-			});
-			batch.exec(function (err) {
-				callback(err);
-			});
+			const batch = redisClient.batch();
+			key.forEach(k => batch.zrem(k, value));
+			await helpers.execBatch(batch);
 		} else {
-			helpers.execKeyValues(redisClient, 'batch', 'zrem', key, value, function (err) {
-				callback(err);
-			});
+			await redisClient.async.zrem(key, value);
 		}
 	};
 
-	module.sortedSetsRemove = function (keys, value, callback) {
-		helpers.execKeysValue(redisClient, 'batch', 'zrem', keys, value, function (err) {
-			callback(err);
-		});
+	module.sortedSetsRemove = async function (keys, value) {
+		await module.sortedSetRemove(keys, value);
 	};
 
-	module.sortedSetsRemoveRangeByScore = function (keys, min, max, callback) {
-		callback = callback || function () {};
+	module.sortedSetsRemoveRangeByScore = async function (keys, min, max) {
 		var batch = redisClient.batch();
-		for (var i = 0; i < keys.length; i += 1) {
-			batch.zremrangebyscore(keys[i], min, max);
-		}
-		batch.exec(function (err) {
-			callback(err);
-		});
+		keys.forEach(k => batch.zremrangebyscore(k, min, max));
+		await helpers.execBatch(batch);
 	};
 };

src/database/redis/sorted/union.js

@@ -2,37 +2,33 @@
 'use strict';
 
 module.exports = function (redisClient, module) {
-	module.sortedSetUnionCard = function (keys, callback) {
+	const helpers = require('../helpers');
+	module.sortedSetUnionCard = async function (keys) {
 		var tempSetName = 'temp_' + Date.now();
 		if (!keys.length) {
-			return setImmediate(callback, null, 0);
+			return 0;
 		}
 		var multi = redisClient.multi();
 		multi.zunionstore([tempSetName, keys.length].concat(keys));
 		multi.zcard(tempSetName);
 		multi.del(tempSetName);
-		multi.exec(function (err, results) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, Array.isArray(results) && results.length ? results[1] : 0);
-		});
+		const results = await helpers.execBatch(multi);
+		return Array.isArray(results) && results.length ? results[1] : 0;
 	};
 
-	module.getSortedSetUnion = function (params, callback) {
+	module.getSortedSetUnion = async function (params) {
 		params.method = 'zrange';
-		module.sortedSetUnion(params, callback);
+		return await module.sortedSetUnion(params);
 	};
 
-	module.getSortedSetRevUnion = function (params, callback) {
+	module.getSortedSetRevUnion = async function (params) {
 		params.method = 'zrevrange';
-		module.sortedSetUnion(params, callback);
+		return await module.sortedSetUnion(params);
 	};
 
-	module.sortedSetUnion = function (params, callback) {
+	module.sortedSetUnion = async function (params) {
 		if (!params.sets.length) {
-			return setImmediate(callback, null, []);
+			return [];
 		}
 
 		var tempSetName = 'temp_' + Date.now();
@@ -46,19 +42,15 @@ module.exports = function (redisClient, module) {
 		multi.zunionstore([tempSetName, params.sets.length].concat(params.sets));
 		multi[params.method](rangeParams);
 		multi.del(tempSetName);
-		multi.exec(function (err, results) {
-			if (err) {
-				return callback(err);
-			}
-			if (!params.withScores) {
-				return callback(null, results ? results[1] : null);
-			}
-			results = results[1] || [];
-			var objects = [];
-			for (var i = 0; i < results.length; i += 2) {
-				objects.push({ value: results[i], score: parseFloat(results[i + 1]) });
-			}
-			callback(null, objects);
-		});
+		let results = await helpers.execBatch(multi);
+		if (!params.withScores) {
+			return results ? results[1] : null;
+		}
+		results = results[1] || [];
+		var objects = [];
+		for (var i = 0; i < results.length; i += 2) {
+			objects.push({ value: results[i], score: parseFloat(results[i + 1]) });
+		}
+		return objects;
 	};
 };