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/postgres/hash.js

@@ -1,74 +1,59 @@
 'use strict';
 
-var async = require('async');
-
 module.exports = function (db, module) {
-	var helpers = module.helpers.postgres;
-
-	module.setObject = function (key, data, callback) {
-		callback = callback || helpers.noop;
+	var helpers = require('./helpers');
 
+	module.setObject = async function (key, data) {
 		if (!key || !data) {
-			return callback();
+			return;
 		}
 
 		if (data.hasOwnProperty('')) {
 			delete data[''];
 		}
 
-		module.transaction(function (tx, done) {
-			var query = tx.client.query.bind(tx.client);
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
 
-			async.series([
-				async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'hash'),
-				async.apply(query, {
-					name: 'setObject',
-					text: `
+			await helpers.ensureLegacyObjectType(client, key, 'hash');
+			await query({
+				name: 'setObject',
+				text: `
 INSERT INTO "legacy_hash" ("_key", "data")
 VALUES ($1::TEXT, $2::TEXT::JSONB)
-    ON CONFLICT ("_key")
-    DO UPDATE SET "data" = "legacy_hash"."data" || $2::TEXT::JSONB`,
-					values: [key, JSON.stringify(data)],
-				}),
-			], function (err) {
-				done(err);
+ON CONFLICT ("_key")
+DO UPDATE SET "data" = "legacy_hash"."data" || $2::TEXT::JSONB`,
+				values: [key, JSON.stringify(data)],
 			});
-		}, callback);
+		});
 	};
 
-	module.setObjectField = function (key, field, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.setObjectField = async function (key, field, value) {
 		if (!field) {
-			return callback();
+			return;
 		}
 
-		module.transaction(function (tx, done) {
-			var query = tx.client.query.bind(tx.client);
-
-			async.series([
-				async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'hash'),
-				async.apply(query, {
-					name: 'setObjectField',
-					text: `
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectType(client, key, 'hash');
+			await query({
+				name: 'setObjectField',
+				text: `
 INSERT INTO "legacy_hash" ("_key", "data")
 VALUES ($1::TEXT, jsonb_build_object($2::TEXT, $3::TEXT::JSONB))
-    ON CONFLICT ("_key")
-    DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], $3::TEXT::JSONB)`,
-					values: [key, field, JSON.stringify(value)],
-				}),
-			], function (err) {
-				done(err);
+ON CONFLICT ("_key")
+DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], $3::TEXT::JSONB)`,
+				values: [key, field, JSON.stringify(value)],
 			});
-		}, callback);
+		});
 	};
 
-	module.getObject = function (key, callback) {
+	module.getObject = async function (key) {
 		if (!key) {
-			return callback(null, null);
+			return null;
 		}
 
-		db.query({
+		const res = await db.query({
 			name: 'getObject',
 			text: `
 SELECT h."data"
@@ -79,25 +64,17 @@ SELECT h."data"
  WHERE o."_key" = $1::TEXT
  LIMIT 1`,
 			values: [key],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, res.rows[0].data);
-			}
-
-			callback(null, null);
 		});
+
+		return res.rows.length ? res.rows[0].data : null;
 	};
 
-	module.getObjects = function (keys, callback) {
+	module.getObjects = async function (keys) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, []);
+			return [];
 		}
 
-		db.query({
+		const res = await db.query({
 			name: 'getObjects',
 			text: `
 SELECT h."data"
@@ -109,23 +86,17 @@ SELECT h."data"
               AND o."type" = h."type"
  ORDER BY k.i ASC`,
 			values: [keys],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, res.rows.map(function (row) {
-				return row.data;
-			}));
 		});
+
+		return res.rows.map(row => row.data);
 	};
 
-	module.getObjectField = function (key, field, callback) {
+	module.getObjectField = async function (key, field) {
 		if (!key) {
-			return setImmediate(callback, null, null);
+			return null;
 		}
 
-		db.query({
+		const res = await db.query({
 			name: 'getObjectField',
 			text: `
 SELECT h."data"->>$2::TEXT f
@@ -136,25 +107,17 @@ SELECT h."data"->>$2::TEXT f
  WHERE o."_key" = $1::TEXT
  LIMIT 1`,
 			values: [key, field],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, res.rows[0].f);
-			}
-
-			callback(null, null);
 		});
+
+		return res.rows.length ? res.rows[0].f : null;
 	};
 
-	module.getObjectFields = function (key, fields, callback) {
+	module.getObjectFields = async function (key, fields) {
 		if (!key) {
-			return setImmediate(callback, null, null);
+			return null;
 		}
 
-		db.query({
+		const res = await db.query({
 			name: 'getObjectFields',
 			text: `
 SELECT (SELECT jsonb_object_agg(f, d."value")
@@ -167,30 +130,26 @@ SELECT (SELECT jsonb_object_agg(f, d."value")
         AND o."type" = h."type"
  WHERE o."_key" = $1::TEXT`,
 			values: [key, fields],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, res.rows[0].d);
-			}
-
-			var obj = {};
-			fields.forEach(function (f) {
-				obj[f] = null;
-			});
-
-			callback(null, obj);
 		});
-	};
 
-	module.getObjectsFields = function (keys, fields, callback) {
-		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, []);
+		if (res.rows.length) {
+			return res.rows[0].d;
 		}
 
-		db.query({
+		var obj = {};
+		fields.forEach(function (f) {
+			obj[f] = null;
+		});
+
+		return obj;
+	};
+
+	module.getObjectsFields = async function (keys, fields) {
+		if (!Array.isArray(keys) || !keys.length) {
+			return [];
+		}
+
+		const res = await db.query({
 			name: 'getObjectsFields',
 			text: `
 SELECT (SELECT jsonb_object_agg(f, d."value")
@@ -205,23 +164,17 @@ SELECT (SELECT jsonb_object_agg(f, d."value")
               AND o."type" = h."type"
  ORDER BY k.i ASC`,
 			values: [keys, fields],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, res.rows.map(function (row) {
-				return row.d;
-			}));
 		});
+
+		return res.rows.map(row => row.d);
 	};
 
-	module.getObjectKeys = function (key, callback) {
+	module.getObjectKeys = async function (key) {
 		if (!key) {
-			return callback();
+			return;
 		}
 
-		db.query({
+		const res = await db.query({
 			name: 'getObjectKeys',
 			text: `
 SELECT ARRAY(SELECT jsonb_object_keys(h."data")) k
@@ -232,45 +185,22 @@ SELECT ARRAY(SELECT jsonb_object_keys(h."data")) k
  WHERE o."_key" = $1::TEXT
  LIMIT 1`,
 			values: [key],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, res.rows[0].k);
-			}
-
-			callback(null, []);
 		});
+
+		return res.rows.length ? res.rows[0].k : [];
 	};
 
-	module.getObjectValues = function (key, callback) {
-		module.getObject(key, function (err, data) {
-			if (err) {
-				return callback(err);
-			}
-
-			var values = [];
-
-			if (data) {
-				for (var key in data) {
-					if (data.hasOwnProperty(key)) {
-						values.push(data[key]);
-					}
-				}
-			}
-
-			callback(null, values);
-		});
+	module.getObjectValues = async function (key) {
+		const data = await module.getObject(key);
+		return data ? Object.values(data) : [];
 	};
 
-	module.isObjectField = function (key, field, callback) {
+	module.isObjectField = async function (key, field) {
 		if (!key) {
-			return callback();
+			return;
 		}
 
-		db.query({
+		const res = await db.query({
 			name: 'isObjectField',
 			text: `
 SELECT (h."data" ? $2::TEXT AND h."data"->>$2::TEXT IS NOT NULL) b
@@ -281,52 +211,33 @@ SELECT (h."data" ? $2::TEXT AND h."data"->>$2::TEXT IS NOT NULL) b
  WHERE o."_key" = $1::TEXT
  LIMIT 1`,
 			values: [key, field],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, res.rows[0].b);
-			}
-
-			callback(null, false);
 		});
+
+		return res.rows.length ? res.rows[0].b : false;
 	};
 
-	module.isObjectFields = function (key, fields, callback) {
+	module.isObjectFields = async function (key, fields) {
 		if (!key) {
-			return callback();
+			return;
 		}
 
-		module.getObjectFields(key, fields, function (err, data) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (!data) {
-				return callback(null, fields.map(function () {
-					return false;
-				}));
-			}
-
-			callback(null, fields.map(function (field) {
-				return data.hasOwnProperty(field) && data[field] !== null;
-			}));
-		});
+		const data = await module.getObjectFields(key, fields);
+		if (!data) {
+			return fields.map(() => false);
+		}
+		return fields.map(field => data.hasOwnProperty(field) && data[field] !== null);
 	};
 
-	module.deleteObjectField = function (key, field, callback) {
-		module.deleteObjectFields(key, [field], callback);
+	module.deleteObjectField = async function (key, field) {
+		await module.deleteObjectFields(key, [field]);
 	};
 
-	module.deleteObjectFields = function (key, fields, callback) {
-		callback = callback || helpers.noop;
+	module.deleteObjectFields = async function (key, fields) {
 		if (!key || !Array.isArray(fields) || !fields.length) {
-			return callback();
+			return;
 		}
 
-		db.query({
+		await db.query({
 			name: 'deleteObjectFields',
 			text: `
 UPDATE "legacy_hash"
@@ -335,57 +246,52 @@ UPDATE "legacy_hash"
                            WHERE "key" <> ALL ($2::TEXT[])), '{}')
  WHERE "_key" = $1::TEXT`,
 			values: [key, fields],
-		}, function (err) {
-			callback(err);
 		});
 	};
 
-	module.incrObjectField = function (key, field, callback) {
-		module.incrObjectFieldBy(key, field, 1, callback);
+	module.incrObjectField = async function (key, field) {
+		return await module.incrObjectFieldBy(key, field, 1);
 	};
 
-	module.decrObjectField = function (key, field, callback) {
-		module.incrObjectFieldBy(key, field, -1, callback);
+	module.decrObjectField = async function (key, field) {
+		return await module.incrObjectFieldBy(key, field, -1);
 	};
 
-	module.incrObjectFieldBy = function (key, field, value, callback) {
-		callback = callback || helpers.noop;
+	module.incrObjectFieldBy = async function (key, field, value) {
 		value = parseInt(value, 10);
 
 		if (!key || isNaN(value)) {
-			return callback(null, null);
+			return null;
 		}
 
-		module.transaction(function (tx, done) {
-			var query = tx.client.query.bind(tx.client);
+		return await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			if (Array.isArray(key)) {
+				await helpers.ensureLegacyObjectsType(client, key, 'hash');
+			} else {
+				await helpers.ensureLegacyObjectType(client, key, 'hash');
+			}
 
-			async.waterfall([
-				async.apply(Array.isArray(key) ? helpers.ensureLegacyObjectsType : helpers.ensureLegacyObjectType, tx.client, key, 'hash'),
-				async.apply(query, Array.isArray(key) ? {
-					name: 'incrObjectFieldByMulti',
-					text: `
+			const res = await query(Array.isArray(key) ? {
+				name: 'incrObjectFieldByMulti',
+				text: `
 INSERT INTO "legacy_hash" ("_key", "data")
 SELECT UNNEST($1::TEXT[]), jsonb_build_object($2::TEXT, $3::NUMERIC)
-    ON CONFLICT ("_key")
-    DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
+ON CONFLICT ("_key")
+DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
 RETURNING ("data"->>$2::TEXT)::NUMERIC v`,
-					values: [key, field, value],
-				} : {
-					name: 'incrObjectFieldBy',
-					text: `
+				values: [key, field, value],
+			} : {
+				name: 'incrObjectFieldBy',
+				text: `
 INSERT INTO "legacy_hash" ("_key", "data")
 VALUES ($1::TEXT, jsonb_build_object($2::TEXT, $3::NUMERIC))
-    ON CONFLICT ("_key")
-    DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
+ON CONFLICT ("_key")
+DO UPDATE SET "data" = jsonb_set("legacy_hash"."data", ARRAY[$2::TEXT], to_jsonb(COALESCE(("legacy_hash"."data"->>$2::TEXT)::NUMERIC, 0) + $3::NUMERIC))
 RETURNING ("data"->>$2::TEXT)::NUMERIC v`,
-					values: [key, field, value],
-				}),
-				function (res, next) {
-					next(null, Array.isArray(key) ? res.rows.map(function (r) {
-						return parseFloat(r.v);
-					}) : parseFloat(res.rows[0].v));
-				},
-			], done);
-		}, callback);
+				values: [key, field, value],
+			});
+			return Array.isArray(key) ? res.rows.map(r => parseFloat(r.v)) : parseFloat(res.rows[0].v);
+		});
 	};
 };