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
2025-11-01 03:26:04 +01:00 · 2019-07-09 12:46:49 -04:00
parent 43ce5f8af3
commit 805dcd7ca2
73 changed files with 4030 additions and 6110 deletions
--- a/src/database/postgres/hash.js
+++ b/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);
+		});
 	};
 };
--- a/src/database/postgres/helpers.js
+++ b/src/database/postgres/helpers.js
@@ -1,6 +1,6 @@
 'use strict';

-var helpers = {};
+var helpers = module.exports;

 helpers.valueToString = function (value) {
 	return String(value);
@@ -19,117 +19,82 @@ helpers.removeDuplicateValues = function (values) {
 	}
 };

-helpers.ensureLegacyObjectType = function (db, key, type, callback) {
-	db.query({
+helpers.ensureLegacyObjectType = async function (db, key, type) {
+	await db.query({
 		name: 'ensureLegacyObjectTypeBefore',
 		text: `
 DELETE FROM "legacy_object"
 WHERE "expireAt" IS NOT NULL
   AND "expireAt" <= CURRENT_TIMESTAMP`,
-	}, function (err) {
-		if (err) {
-			return callback(err);
-		}
+	});

-		db.query({
-			name: 'ensureLegacyObjectType1',
-			text: `
+	await db.query({
+		name: 'ensureLegacyObjectType1',
+		text: `
 INSERT INTO "legacy_object" ("_key", "type")
 VALUES ($1::TEXT, $2::TEXT::LEGACY_OBJECT_TYPE)
    ON CONFLICT
    DO NOTHING`,
-			values: [key, type],
-		}, function (err) {
-			if (err) {
-				return callback(err);
-			}
+		values: [key, type],
+	});

-			db.query({
-				name: 'ensureLegacyObjectType2',
-				text: `
+	const res = await db.query({
+		name: 'ensureLegacyObjectType2',
+		text: `
 SELECT "type"
  FROM "legacy_object_live"
 WHERE "_key" = $1::TEXT`,
-				values: [key],
-			}, function (err, res) {
-				if (err) {
-					return callback(err);
-				}
-
-				if (res.rows[0].type !== type) {
-					return callback(new Error('database: cannot insert ' + JSON.stringify(key) + ' as ' + type + ' because it already exists as ' + res.rows[0].type));
-				}
-
-				callback(null);
-			});
-		});
+		values: [key],
 	});
+
+	if (res.rows[0].type !== type) {
+		throw new Error('database: cannot insert ' + JSON.stringify(key) + ' as ' + type + ' because it already exists as ' + res.rows[0].type);
+	}
 };

-helpers.ensureLegacyObjectsType = function (db, keys, type, callback) {
-	db.query({
+helpers.ensureLegacyObjectsType = async function (db, keys, type) {
+	await db.query({
 		name: 'ensureLegacyObjectTypeBefore',
 		text: `
 DELETE FROM "legacy_object"
 WHERE "expireAt" IS NOT NULL
   AND "expireAt" <= CURRENT_TIMESTAMP`,
-	}, function (err) {
-		if (err) {
-			return callback(err);
-		}
+	});

-		db.query({
-			name: 'ensureLegacyObjectsType1',
-			text: `
+	await db.query({
+		name: 'ensureLegacyObjectsType1',
+		text: `
 INSERT INTO "legacy_object" ("_key", "type")
 SELECT k, $2::TEXT::LEGACY_OBJECT_TYPE
  FROM UNNEST($1::TEXT[]) k
    ON CONFLICT
    DO NOTHING`,
-			values: [keys, type],
-		}, function (err) {
-			if (err) {
-				return callback(err);
-			}
+		values: [keys, type],
+	});

-			db.query({
-				name: 'ensureLegacyObjectsType2',
-				text: `
+	const res = await db.query({
+		name: 'ensureLegacyObjectsType2',
+		text: `
 SELECT "_key", "type"
  FROM "legacy_object_live"
 WHERE "_key" = ANY($1::TEXT[])`,
-				values: [keys],
-			}, function (err, res) {
-				if (err) {
-					return callback(err);
-				}
-
-				var invalid = res.rows.filter(function (r) {
-					return r.type !== type;
-				});
-
-				if (invalid.length) {
-					return callback(new Error('database: cannot insert multiple objects as ' + type + ' because they already exist: ' + invalid.map(function (r) {
-						return JSON.stringify(r._key) + ' is ' + r.type;
-					}).join(', ')));
-				}
-
-				var missing = keys.filter(function (k) {
-					return !res.rows.some(function (r) {
-						return r._key === k;
-					});
-				});
-
-				if (missing.length) {
-					return callback(new Error('database: failed to insert keys for objects: ' + JSON.stringify(missing)));
-				}
-
-				callback(null);
-			});
-		});
+		values: [keys],
 	});
+
+	var invalid = res.rows.filter(r => r.type !== type);
+
+	if (invalid.length) {
+		const parts = invalid.map(r => JSON.stringify(r._key) + ' is ' + r.type);
+		throw new Error('database: cannot insert multiple objects as ' + type + ' because they already exist: ' + parts.join(', '));
+	}
+
+	var missing = keys.filter(function (k) {
+		return !res.rows.some(r => r._key === k);
+	});
+
+	if (missing.length) {
+		throw new Error('database: failed to insert keys for objects: ' + JSON.stringify(missing));
+	}
 };

 helpers.noop = function () {};
-
-module.exports = helpers;
--- a/src/database/postgres/list.js
+++ b/src/database/postgres/list.js
@@ -1,72 +1,54 @@
 'use strict';

-var async = require('async');
-
 module.exports = function (db, module) {
-	var helpers = module.helpers.postgres;
-
-	module.listPrepend = function (key, value, callback) {
-		callback = callback || helpers.noop;
+	var helpers = require('./helpers');

+	module.listPrepend = async function (key, value) {
 		if (!key) {
-			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, 'list'),
-				async.apply(query, {
-					name: 'listPrepend',
-					text: `
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectType(client, key, 'list');
+			await query({
+				name: 'listPrepend',
+				text: `
 INSERT INTO "legacy_list" ("_key", "array")
 VALUES ($1::TEXT, ARRAY[$2::TEXT])
-    ON CONFLICT ("_key")
-    DO UPDATE SET "array" = ARRAY[$2::TEXT] || "legacy_list"."array"`,
-					values: [key, value],
-				}),
-			], function (err) {
-				done(err);
+ON CONFLICT ("_key")
+DO UPDATE SET "array" = ARRAY[$2::TEXT] || "legacy_list"."array"`,
+				values: [key, value],
 			});
-		}, callback);
+		});
 	};

-	module.listAppend = function (key, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.listAppend = async function (key, value) {
 		if (!key) {
-			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, 'list'),
-				async.apply(query, {
-					name: 'listAppend',
-					text: `
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectType(client, key, 'list');
+			await query({
+				name: 'listAppend',
+				text: `
 INSERT INTO "legacy_list" ("_key", "array")
 VALUES ($1::TEXT, ARRAY[$2::TEXT])
-    ON CONFLICT ("_key")
-    DO UPDATE SET "array" = "legacy_list"."array" || ARRAY[$2::TEXT]`,
-					values: [key, value],
-				}),
-			], function (err) {
-				done(err);
+ON CONFLICT ("_key")
+DO UPDATE SET "array" = "legacy_list"."array" || ARRAY[$2::TEXT]`,
+				values: [key, value],
 			});
-		}, callback || helpers.noop);
+		});
 	};

-	module.listRemoveLast = function (key, callback) {
-		callback = callback || helpers.noop;
-
+	module.listRemoveLast = async function (key) {
 		if (!key) {
-			return callback();
+			return;
 		}

-		db.query({
+		const res = await db.query({
 			name: 'listRemoveLast',
 			text: `
 WITH A AS (
@@ -83,27 +65,17 @@ UPDATE "legacy_list" l
 WHERE A."_key" = l."_key"
 RETURNING A."array"[array_length(A."array", 1)] v`,
 			values: [key],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, res.rows[0].v);
-			}
-
-			callback(null, null);
 		});
+
+		return res.rows.length ? res.rows[0].v : null;
 	};

-	module.listRemoveAll = function (key, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.listRemoveAll = async function (key, value) {
 		if (!key) {
-			return callback();
+			return;
 		}

-		db.query({
+		await db.query({
 			name: 'listRemoveAll',
 			text: `
 UPDATE "legacy_list" l
@@ -113,21 +85,17 @@ UPDATE "legacy_list" l
   AND o."type" = l."type"
   AND o."_key" = $1::TEXT`,
 			values: [key, value],
-		}, function (err) {
-			callback(err);
 		});
 	};

-	module.listTrim = function (key, start, stop, callback) {
-		callback = callback || helpers.noop;
-
+	module.listTrim = async function (key, start, stop) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		stop += 1;

-		db.query(stop > 0 ? {
+		await db.query(stop > 0 ? {
 			name: 'listTrim',
 			text: `
 UPDATE "legacy_list" l
@@ -155,19 +123,17 @@ UPDATE "legacy_list" l
   AND o."type" = l."type"
   AND o."_key" = $1::TEXT`,
 			values: [key, start, stop],
-		}, function (err) {
-			callback(err);
 		});
 	};

-	module.getListRange = function (key, start, stop, callback) {
+	module.getListRange = async function (key, start, stop) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		stop += 1;

-		db.query(stop > 0 ? {
+		const res = await db.query(stop > 0 ? {
 			name: 'getListRange',
 			text: `
 SELECT ARRAY(SELECT m.m
@@ -195,21 +161,13 @@ SELECT ARRAY(SELECT m.m
        AND o."type" = l."type"
 WHERE o."_key" = $1::TEXT`,
 			values: [key, start, stop],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, res.rows[0].l);
-			}
-
-			callback(null, []);
 		});
+
+		return res.rows.length ? res.rows[0].l : [];
 	};

-	module.listLength = function (key, callback) {
-		db.query({
+	module.listLength = async function (key) {
+		const res = await db.query({
 			name: 'listLength',
 			text: `
 SELECT array_length(l."array", 1) l
@@ -219,16 +177,8 @@ SELECT array_length(l."array", 1) l
        AND o."type" = l."type"
      WHERE o."_key" = $1::TEXT`,
 			values: [key],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, res.rows[0].l);
-			}
-
-			callback(null, 0);
 		});
+
+		return res.rows.length ? res.rows[0].l : 0;
 	};
 };
--- a/src/database/postgres/main.js
+++ b/src/database/postgres/main.js
@@ -1,114 +1,83 @@
 'use strict';

-var async = require('async');
-
 module.exports = function (db, module) {
-	var helpers = module.helpers.postgres;
+	var helpers = require('./helpers');

 	var query = db.query.bind(db);

-	module.flushdb = function (callback) {
-		callback = callback || helpers.noop;
-
-		async.series([
-			async.apply(query, `DROP SCHEMA "public" CASCADE`),
-			async.apply(query, `CREATE SCHEMA "public"`),
-		], function (err) {
-			callback(err);
-		});
+	module.flushdb = async function () {
+		await query(`DROP SCHEMA "public" CASCADE`);
+		await query(`CREATE SCHEMA "public"`);
 	};

-	module.emptydb = function (callback) {
-		callback = callback || helpers.noop;
-		query(`DELETE FROM "legacy_object"`, function (err) {
-			callback(err);
-		});
+	module.emptydb = async function () {
+		await query(`DELETE FROM "legacy_object"`);
 	};

-	module.exists = function (key, callback) {
+	module.exists = async function (key) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		if (Array.isArray(key)) {
-			query({
+			const res = await query({
 				name: 'existsArray',
 				text: `
 				SELECT o."_key" k
  				FROM "legacy_object_live" o
 				WHERE o."_key" = ANY($1::TEXT[])`,
 				values: [key],
-			}, function (err, res) {
-				if (err) {
-					return callback(err);
-				}
-
-				callback(null, key.map(function (k) {
-					return res.rows.some(function (r) {
-						return r.k === k;
-					});
-				}));
 			});
-		} else {
-			query({
-				name: 'exists',
-				text: `
-	SELECT EXISTS(SELECT *
+			return key.map(function (k) {
+				return res.rows.some(r => r.k === k);
+			});
+		}
+		const res =	await query({
+			name: 'exists',
+			text: `
+			SELECT EXISTS(SELECT *
 					FROM "legacy_object_live"
 				   WHERE "_key" = $1::TEXT
 				   LIMIT 1) e`,
-				values: [key],
-			}, function (err, res) {
-				if (err) {
-					return callback(err);
-				}
-
-				callback(null, res.rows[0].e);
-			});
-		}
+			values: [key],
+		});
+		return res.rows[0].e;
 	};

-	module.delete = function (key, callback) {
-		callback = callback || helpers.noop;
+	module.delete = async function (key) {
 		if (!key) {
-			return callback();
+			return;
 		}

-		query({
+		await query({
 			name: 'delete',
 			text: `
 DELETE FROM "legacy_object"
 WHERE "_key" = $1::TEXT`,
 			values: [key],
-		}, function (err) {
-			callback(err);
 		});
 	};

-	module.deleteAll = function (keys, callback) {
-		callback = callback || helpers.noop;
-
+	module.deleteAll = async function (keys) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback();
+			return;
 		}

-		query({
+		await query({
 			name: 'deleteAll',
 			text: `
 DELETE FROM "legacy_object"
 WHERE "_key" = ANY($1::TEXT[])`,
 			values: [keys],
-		}, function (err) {
-			callback(err);
 		});
 	};

-	module.get = function (key, callback) {
+	module.get = async function (key) {
 		if (!key) {
-			return callback();
+			return;
 		}

-		query({
+		const res = await query({
 			name: 'get',
 			text: `
 SELECT s."data" t
@@ -119,94 +88,76 @@ SELECT s."data" t
 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].t);
-			}
+		return res.rows.length ? res.rows[0].t : null;
+	};

-			callback(null, null);
+	module.set = async function (key, value) {
+		if (!key) {
+			return;
+		}
+
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectType(client, key, 'string');
+			await query({
+				name: 'set',
+				text: `
+INSERT INTO "legacy_string" ("_key", "data")
+VALUES ($1::TEXT, $2::TEXT)
+ON CONFLICT ("_key")
+DO UPDATE SET "data" = $2::TEXT`,
+				values: [key, value],
+			});
 		});
 	};

-	module.set = function (key, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.increment = async function (key) {
 		if (!key) {
-			return callback();
+			return;
 		}

-		module.transaction(function (tx, done) {
-			async.series([
-				async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'string'),
-				async.apply(tx.client.query.bind(tx.client), {
-					name: 'set',
-					text: `
-INSERT INTO "legacy_string" ("_key", "data")
-VALUES ($1::TEXT, $2::TEXT)
-    ON CONFLICT ("_key")
-    DO UPDATE SET "data" = $2::TEXT`,
-					values: [key, value],
-				}),
-			], function (err) {
-				done(err);
-			});
-		}, callback);
-	};
-
-	module.increment = function (key, callback) {
-		callback = callback || helpers.noop;
-
-		if (!key) {
-			return callback();
-		}
-
-		module.transaction(function (tx, done) {
-			async.waterfall([
-				async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'string'),
-				async.apply(tx.client.query.bind(tx.client), {
-					name: 'increment',
-					text: `
+		return await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectType(client, key, 'string');
+			const res = await query({
+				name: 'increment',
+				text: `
 INSERT INTO "legacy_string" ("_key", "data")
 VALUES ($1::TEXT, '1')
-    ON CONFLICT ("_key")
-    DO UPDATE SET "data" = ("legacy_string"."data"::NUMERIC + 1)::TEXT
+ON CONFLICT ("_key")
+DO UPDATE SET "data" = ("legacy_string"."data"::NUMERIC + 1)::TEXT
 RETURNING "data" d`,
-					values: [key],
-				}),
-			], function (err, res) {
-				if (err) {
-					return done(err);
-				}
-
-				done(null, parseFloat(res.rows[0].d));
+				values: [key],
 			});
-		}, callback);
+			return parseFloat(res.rows[0].d);
+		});
 	};

-	module.rename = function (oldKey, newKey, callback) {
-		module.transaction(function (tx, done) {
-			async.series([
-				async.apply(tx.delete, newKey),
-				async.apply(tx.client.query.bind(tx.client), {
-					name: 'rename',
-					text: `
+	module.rename = async function (oldKey, newKey) {
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await query({
+				name: 'deleteRename',
+				text: `
+	DELETE FROM "legacy_object"
+	 WHERE "_key" = $1::TEXT`,
+				values: [newKey],
+			});
+			await query({
+				name: 'rename',
+				text: `
 UPDATE "legacy_object"
-   SET "_key" = $2::TEXT
- WHERE "_key" = $1::TEXT`,
-					values: [oldKey, newKey],
-				}),
-			], function (err) {
-				done(err);
+SET "_key" = $2::TEXT
+WHERE "_key" = $1::TEXT`,
+				values: [oldKey, newKey],
 			});
-		}, callback || helpers.noop);
+		});
 	};

-	module.type = function (key, callback) {
-		query({
+	module.type = async function (key) {
+		const res = await query({
 			name: 'type',
 			text: `
 SELECT "type"::TEXT t
@@ -214,47 +165,35 @@ SELECT "type"::TEXT t
 WHERE "_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].t);
-			}
-
-			callback(null, null);
 		});
+
+		return res.rows.length ? res.rows[0].t : null;
 	};

-	function doExpire(key, date, callback) {
-		query({
+	async function doExpire(key, date) {
+		await query({
 			name: 'expire',
 			text: `
 UPDATE "legacy_object"
   SET "expireAt" = $2::TIMESTAMPTZ
 WHERE "_key" = $1::TEXT`,
 			values: [key, date],
-		}, function (err) {
-			if (callback) {
-				callback(err);
-			}
 		});
 	}

-	module.expire = function (key, seconds, callback) {
-		doExpire(key, new Date(((Date.now() / 1000) + seconds) * 1000), callback);
+	module.expire = async function (key, seconds) {
+		await doExpire(key, new Date(((Date.now() / 1000) + seconds) * 1000));
 	};

-	module.expireAt = function (key, timestamp, callback) {
-		doExpire(key, new Date(timestamp * 1000), callback);
+	module.expireAt = async function (key, timestamp) {
+		await doExpire(key, new Date(timestamp * 1000));
 	};

-	module.pexpire = function (key, ms, callback) {
-		doExpire(key, new Date(Date.now() + parseInt(ms, 10)), callback);
+	module.pexpire = async function (key, ms) {
+		await doExpire(key, new Date(Date.now() + parseInt(ms, 10)));
 	};

-	module.pexpireAt = function (key, timestamp, callback) {
-		doExpire(key, new Date(timestamp), callback);
+	module.pexpireAt = async function (key, timestamp) {
+		await doExpire(key, new Date(timestamp));
 	};
 };
--- a/src/database/postgres/sets.js
+++ b/src/database/postgres/sets.js
@@ -1,44 +1,34 @@
 'use strict';

-var async = require('async');
 var _ = require('lodash');

 module.exports = function (db, module) {
-	var helpers = module.helpers.postgres;
-
-	module.setAdd = function (key, value, callback) {
-		callback = callback || helpers.noop;
+	var helpers = require('./helpers');

+	module.setAdd = async function (key, value) {
 		if (!Array.isArray(value)) {
 			value = [value];
 		}

-		module.transaction(function (tx, done) {
-			var query = tx.client.query.bind(tx.client);
-
-			async.series([
-				async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'set'),
-				async.apply(query, {
-					name: 'setAdd',
-					text: `
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectType(client, key, 'set');
+			await query({
+				name: 'setAdd',
+				text: `
 INSERT INTO "legacy_set" ("_key", "member")
 SELECT $1::TEXT, m
-  FROM UNNEST($2::TEXT[]) m
-    ON CONFLICT ("_key", "member")
-    DO NOTHING`,
-					values: [key, value],
-				}),
-			], function (err) {
-				done(err);
+FROM UNNEST($2::TEXT[]) m
+ON CONFLICT ("_key", "member")
+DO NOTHING`,
+				values: [key, value],
 			});
-		}, callback);
+		});
 	};

-	module.setsAdd = function (keys, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.setsAdd = async function (keys, value) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback();
+			return;
 		}

 		if (!Array.isArray(value)) {
@@ -47,31 +37,24 @@ SELECT $1::TEXT, m

 		keys = _.uniq(keys);

-		module.transaction(function (tx, done) {
-			var query = tx.client.query.bind(tx.client);
-
-			async.series([
-				async.apply(helpers.ensureLegacyObjectsType, tx.client, keys, 'set'),
-				async.apply(query, {
-					name: 'setsAdd',
-					text: `
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectsType(client, keys, 'set');
+			await query({
+				name: 'setsAdd',
+				text: `
 INSERT INTO "legacy_set" ("_key", "member")
 SELECT k, m
-  FROM UNNEST($1::TEXT[]) k
- CROSS JOIN UNNEST($2::TEXT[]) m
-    ON CONFLICT ("_key", "member")
-    DO NOTHING`,
-					values: [keys, value],
-				}),
-			], function (err) {
-				done(err);
+FROM UNNEST($1::TEXT[]) k
+CROSS JOIN UNNEST($2::TEXT[]) m
+ON CONFLICT ("_key", "member")
+DO NOTHING`,
+				values: [keys, value],
 			});
-		}, callback);
+		});
 	};

-	module.setRemove = function (key, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.setRemove = async function (key, value) {
 		if (!Array.isArray(key)) {
 			key = [key];
 		}
@@ -80,43 +63,37 @@ SELECT k, m
 			value = [value];
 		}

-		db.query({
+		await db.query({
 			name: 'setRemove',
 			text: `
 DELETE FROM "legacy_set"
 WHERE "_key" = ANY($1::TEXT[])
   AND "member" = ANY($2::TEXT[])`,
 			values: [key, value],
-		}, function (err) {
-			callback(err);
 		});
 	};

-	module.setsRemove = function (keys, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.setsRemove = async function (keys, value) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback();
+			return;
 		}

-		db.query({
+		await db.query({
 			name: 'setsRemove',
 			text: `
 DELETE FROM "legacy_set"
 WHERE "_key" = ANY($1::TEXT[])
   AND "member" = $2::TEXT`,
 			values: [keys, value],
-		}, function (err) {
-			callback(err);
 		});
 	};

-	module.isSetMember = function (key, value, callback) {
+	module.isSetMember = async function (key, value) {
 		if (!key) {
-			return callback(null, false);
+			return false;
 		}

-		db.query({
+		const res = await db.query({
 			name: 'isSetMember',
 			text: `
 SELECT 1
@@ -127,23 +104,19 @@ SELECT 1
 WHERE o."_key" = $1::TEXT
   AND s."member" = $2::TEXT`,
 			values: [key, value],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, !!res.rows.length);
 		});
+
+		return !!res.rows.length;
 	};

-	module.isSetMembers = function (key, values, callback) {
+	module.isSetMembers = async function (key, values) {
 		if (!key || !Array.isArray(values) || !values.length) {
-			return callback(null, []);
+			return [];
 		}

 		values = values.map(helpers.valueToString);

-		db.query({
+		const res = await db.query({
 			name: 'isSetMembers',
 			text: `
 SELECT s."member" m
@@ -154,27 +127,21 @@ SELECT s."member" m
 WHERE o."_key" = $1::TEXT
   AND s."member" = ANY($2::TEXT[])`,
 			values: [key, values],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, values.map(function (v) {
-				return res.rows.some(function (r) {
-					return r.m === v;
-				});
-			}));
+		return values.map(function (v) {
+			return res.rows.some(r => r.m === v);
 		});
 	};

-	module.isMemberOfSets = function (sets, value, callback) {
+	module.isMemberOfSets = async function (sets, value) {
 		if (!Array.isArray(sets) || !sets.length) {
-			return callback(null, []);
+			return [];
 		}

 		value = helpers.valueToString(value);

-		db.query({
+		const res = await db.query({
 			name: 'isMemberOfSets',
 			text: `
 SELECT o."_key" k
@@ -185,25 +152,19 @@ SELECT o."_key" k
 WHERE o."_key" = ANY($1::TEXT[])
   AND s."member" = $2::TEXT`,
 			values: [sets, value],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, sets.map(function (s) {
-				return res.rows.some(function (r) {
-					return r.k === s;
-				});
-			}));
+		return sets.map(function (s) {
+			return res.rows.some(r => r.k === s);
 		});
 	};

-	module.getSetMembers = function (key, callback) {
+	module.getSetMembers = async function (key) {
 		if (!key) {
-			return callback(null, []);
+			return [];
 		}

-		db.query({
+		const res = await db.query({
 			name: 'getSetMembers',
 			text: `
 SELECT s."member" m
@@ -213,23 +174,17 @@ SELECT s."member" m
        AND o."type" = s."type"
 WHERE o."_key" = $1::TEXT`,
 			values: [key],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, res.rows.map(function (r) {
-				return r.m;
-			}));
 		});
+
+		return res.rows.map(r => r.m);
 	};

-	module.getSetsMembers = function (keys, callback) {
+	module.getSetsMembers = async function (keys) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, []);
+			return [];
 		}

-		db.query({
+		const res = await db.query({
 			name: 'getSetsMembers',
 			text: `
 SELECT o."_key" k,
@@ -241,25 +196,19 @@ SELECT o."_key" k,
 WHERE o."_key" = ANY($1::TEXT[])
 GROUP BY o."_key"`,
 			values: [keys],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, keys.map(function (k) {
-				return (res.rows.find(function (r) {
-					return r.k === k;
-				}) || { m: [] }).m;
-			}));
+		return keys.map(function (k) {
+			return (res.rows.find(r => r.k === k) || { m: [] }).m;
 		});
 	};

-	module.setCount = function (key, callback) {
+	module.setCount = async function (key) {
 		if (!key) {
-			return callback(null, 0);
+			return 0;
 		}

-		db.query({
+		const res = await db.query({
 			name: 'setCount',
 			text: `
 SELECT COUNT(*) c
@@ -269,17 +218,13 @@ SELECT COUNT(*) c
        AND o."type" = s."type"
 WHERE o."_key" = $1::TEXT`,
 			values: [key],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, parseInt(res.rows[0].c, 10));
 		});
+
+		return parseInt(res.rows[0].c, 10);
 	};

-	module.setsCount = function (keys, callback) {
-		db.query({
+	module.setsCount = async function (keys) {
+		const res = await db.query({
 			name: 'setsCount',
 			text: `
 SELECT o."_key" k,
@@ -291,23 +236,15 @@ SELECT o."_key" k,
 WHERE o."_key" = ANY($1::TEXT[])
 GROUP BY o."_key"`,
 			values: [keys],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, keys.map(function (k) {
-				return (res.rows.find(function (r) {
-					return r.k === k;
-				}) || { c: 0 }).c;
-			}));
+		return keys.map(function (k) {
+			return (res.rows.find(r => r.k === k) || { c: 0 }).c;
 		});
 	};

-	module.setRemoveRandom = function (key, callback) {
-		callback = callback || helpers.noop;
-
-		db.query({
+	module.setRemoveRandom = async function (key) {
+		const res = await db.query({
 			name: 'setRemoveRandom',
 			text: `
 WITH A AS (
@@ -326,16 +263,7 @@ DELETE FROM "legacy_set" s
   AND s."member" = A."member"
 RETURNING A."member" m`,
 			values: [key],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, res.rows[0].m);
-			}
-
-			callback(null, null);
 		});
+		return res.rows.length ? res.rows[0].m : null;
 	};
 };
--- a/src/database/postgres/sorted.js
+++ b/src/database/postgres/sorted.js
@@ -1,9 +1,11 @@
 'use strict';

-var async = require('async');
-
 module.exports = function (db, module) {
-	var helpers = module.helpers.postgres;
+	var helpers = require('./helpers');
+	const util = require('util');
+	var Cursor = require('pg-cursor');
+	Cursor.prototype.readAsync = util.promisify(Cursor.prototype.read);
+	const sleep = util.promisify(setTimeout);

 	var query = db.query.bind(db);

@@ -12,25 +14,25 @@ module.exports = function (db, module) {
 	require('./sorted/union')(db, module);
 	require('./sorted/intersect')(db, module);

-	module.getSortedSetRange = function (key, start, stop, callback) {
-		getSortedSetRange(key, start, stop, 1, false, callback);
+	module.getSortedSetRange = async function (key, start, stop) {
+		return await getSortedSetRange(key, start, stop, 1, false);
 	};

-	module.getSortedSetRevRange = function (key, start, stop, callback) {
-		getSortedSetRange(key, start, stop, -1, false, callback);
+	module.getSortedSetRevRange = async function (key, start, stop) {
+		return await getSortedSetRange(key, start, stop, -1, false);
 	};

-	module.getSortedSetRangeWithScores = function (key, start, stop, callback) {
-		getSortedSetRange(key, start, stop, 1, true, callback);
+	module.getSortedSetRangeWithScores = async function (key, start, stop) {
+		return await getSortedSetRange(key, start, stop, 1, true);
 	};

-	module.getSortedSetRevRangeWithScores = function (key, start, stop, callback) {
-		getSortedSetRange(key, start, stop, -1, true, callback);
+	module.getSortedSetRevRangeWithScores = async function (key, start, stop) {
+		return await getSortedSetRange(key, start, stop, -1, true);
 	};

-	function getSortedSetRange(key, start, stop, sort, withScores, callback) {
+	async function getSortedSetRange(key, start, stop, sort, withScores) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		if (!Array.isArray(key)) {
@@ -38,7 +40,7 @@ module.exports = function (db, module) {
 		}

 		if (start < 0 && start > stop) {
-			return callback(null, []);
+			return [];
 		}

 		var reverse = false;
@@ -58,7 +60,7 @@ module.exports = function (db, module) {
 			limit = null;
 		}

-		query({
+		const res = await query({
 			name: 'getSortedSetRangeWithScores' + (sort > 0 ? 'Asc' : 'Desc'),
 			text: `
 SELECT z."value",
@@ -72,51 +74,40 @@ SELECT z."value",
 LIMIT $3::INTEGER
 OFFSET $2::INTEGER`,
 			values: [key, start, limit],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (reverse) {
-				res.rows.reverse();
-			}
-
-			if (withScores) {
-				res.rows = res.rows.map(function (r) {
-					return {
-						value: r.value,
-						score: parseFloat(r.score),
-					};
-				});
-			} else {
-				res.rows = res.rows.map(function (r) {
-					return r.value;
-				});
-			}
-
-			callback(null, res.rows);
 		});
+
+		if (reverse) {
+			res.rows.reverse();
+		}
+
+		if (withScores) {
+			res.rows = res.rows.map(r => ({ value: r.value, score: parseFloat(r.score) }));
+		} else {
+			res.rows = res.rows.map(r => r.value);
+		}
+
+		return res.rows;
 	}

-	module.getSortedSetRangeByScore = function (key, start, count, min, max, callback) {
-		getSortedSetRangeByScore(key, start, count, min, max, 1, false, callback);
+	module.getSortedSetRangeByScore = async function (key, start, count, min, max) {
+		return await getSortedSetRangeByScore(key, start, count, min, max, 1, false);
 	};

-	module.getSortedSetRevRangeByScore = function (key, start, count, max, min, callback) {
-		getSortedSetRangeByScore(key, start, count, min, max, -1, false, callback);
+	module.getSortedSetRevRangeByScore = async function (key, start, count, max, min) {
+		return await getSortedSetRangeByScore(key, start, count, min, max, -1, false);
 	};

-	module.getSortedSetRangeByScoreWithScores = function (key, start, count, min, max, callback) {
-		getSortedSetRangeByScore(key, start, count, min, max, 1, true, callback);
+	module.getSortedSetRangeByScoreWithScores = async function (key, start, count, min, max) {
+		return await getSortedSetRangeByScore(key, start, count, min, max, 1, true);
 	};

-	module.getSortedSetRevRangeByScoreWithScores = function (key, start, count, max, min, callback) {
-		getSortedSetRangeByScore(key, start, count, min, max, -1, true, callback);
+	module.getSortedSetRevRangeByScoreWithScores = async function (key, start, count, max, min) {
+		return await getSortedSetRangeByScore(key, start, count, min, max, -1, true);
 	};

-	function getSortedSetRangeByScore(key, start, count, min, max, sort, withScores, callback) {
+	async function getSortedSetRangeByScore(key, start, count, min, max, sort, withScores) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		if (!Array.isArray(key)) {
@@ -134,7 +125,7 @@ OFFSET $2::INTEGER`,
 			max = null;
 		}

-		query({
+		const res = await query({
 			name: 'getSortedSetRangeByScoreWithScores' + (sort > 0 ? 'Asc' : 'Desc'),
 			text: `
 SELECT z."value",
@@ -150,31 +141,20 @@ SELECT z."value",
 LIMIT $3::INTEGER
 OFFSET $2::INTEGER`,
 			values: [key, start, count, min, max],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (withScores) {
-				res.rows = res.rows.map(function (r) {
-					return {
-						value: r.value,
-						score: parseFloat(r.score),
-					};
-				});
-			} else {
-				res.rows = res.rows.map(function (r) {
-					return r.value;
-				});
-			}
-
-			return callback(null, res.rows);
 		});
+
+		if (withScores) {
+			res.rows = res.rows.map(r => ({ value: r.value, score: parseFloat(r.score) }));
+		} else {
+			res.rows = res.rows.map(r => r.value);
+		}
+
+		return res.rows;
 	}

-	module.sortedSetCount = function (key, min, max, callback) {
+	module.sortedSetCount = async function (key, min, max) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		if (min === '-inf') {
@@ -184,7 +164,7 @@ OFFSET $2::INTEGER`,
 			max = null;
 		}

-		query({
+		const res = await query({
 			name: 'sortedSetCount',
 			text: `
 SELECT COUNT(*) c
@@ -196,21 +176,17 @@ SELECT COUNT(*) c
   AND (z."score" >= $2::NUMERIC OR $2::NUMERIC IS NULL)
   AND (z."score" <= $3::NUMERIC OR $3::NUMERIC IS NULL)`,
 			values: [key, min, max],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, parseInt(res.rows[0].c, 10));
 		});
+
+		return parseInt(res.rows[0].c, 10);
 	};

-	module.sortedSetCard = function (key, callback) {
+	module.sortedSetCard = async function (key) {
 		if (!key) {
-			return callback(null, 0);
+			return 0;
 		}

-		query({
+		const res = await query({
 			name: 'sortedSetCard',
 			text: `
 SELECT COUNT(*) c
@@ -220,21 +196,17 @@ SELECT COUNT(*) c
        AND o."type" = z."type"
 WHERE o."_key" = $1::TEXT`,
 			values: [key],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, parseInt(res.rows[0].c, 10));
 		});
+
+		return parseInt(res.rows[0].c, 10);
 	};

-	module.sortedSetsCard = function (keys, callback) {
+	module.sortedSetsCard = async function (keys) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, []);
+			return [];
 		}

-		query({
+		const res = await query({
 			name: 'sortedSetsCard',
 			text: `
 SELECT o."_key" k,
@@ -246,50 +218,38 @@ SELECT o."_key" k,
 WHERE o."_key" = ANY($1::TEXT[])
 GROUP BY o."_key"`,
 			values: [keys],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, keys.map(function (k) {
-				return parseInt((res.rows.find(function (r) {
-					return r.k === k;
-				}) || { c: 0 }).c, 10);
-			}));
+		return keys.map(function (k) {
+			return parseInt((res.rows.find(r => r.k === k) || { c: 0 }).c, 10);
 		});
 	};

-	module.sortedSetsCardSum = function (keys, callback) {
+	module.sortedSetsCardSum = async function (keys) {
 		if (!keys || (Array.isArray(keys) && !keys.length)) {
-			return callback(null, 0);
+			return 0;
 		}
 		if (!Array.isArray(keys)) {
 			keys = [keys];
 		}
-		module.sortedSetsCard(keys, function (err, counts) {
-			if (err) {
-				return callback(err);
-			}
-			const sum = counts.reduce(function (acc, val) { return acc + val; }, 0);
-			callback(null, sum);
-		});
+		const counts = await module.sortedSetsCard(keys);
+		const sum = counts.reduce((acc, val) => acc + val, 0);
+		return sum;
 	};

-	module.sortedSetRank = function (key, value, callback) {
-		getSortedSetRank('ASC', [key], [value], function (err, result) {
-			callback(err, result ? result[0] : null);
-		});
+	module.sortedSetRank = async function (key, value) {
+		const result = await getSortedSetRank('ASC', [key], [value]);
+		return result ? result[0] : null;
 	};

-	module.sortedSetRevRank = function (key, value, callback) {
-		getSortedSetRank('DESC', [key], [value], function (err, result) {
-			callback(err, result ? result[0] : null);
-		});
+	module.sortedSetRevRank = async function (key, value) {
+		const result = await getSortedSetRank('DESC', [key], [value]);
+		return result ? result[0] : null;
 	};

-	function getSortedSetRank(sort, keys, values, callback) {
+	async function getSortedSetRank(sort, keys, values) {
 		values = values.map(helpers.valueToString);
-		query({
+		const res = await query({
 			name: 'getSortedSetRank' + sort,
 			text: `
 SELECT (SELECT r
@@ -306,55 +266,51 @@ SELECT (SELECT r
  FROM UNNEST($1::TEXT[], $2::TEXT[]) WITH ORDINALITY kvi(k, v, i)
 ORDER BY kvi.i ASC`,
 			values: [keys, values],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, res.rows.map(function (r) { return r.r === null ? null : parseFloat(r.r); }));
 		});
+
+		return res.rows.map(r => (r.r === null ? null : parseFloat(r.r)));
 	}

-	module.sortedSetsRanks = function (keys, values, callback) {
+	module.sortedSetsRanks = async function (keys, values) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, []);
+			return [];
 		}

-		getSortedSetRank('ASC', keys, values, callback);
+		return await getSortedSetRank('ASC', keys, values);
 	};

-	module.sortedSetsRevRanks = function (keys, values, callback) {
+	module.sortedSetsRevRanks = async function (keys, values) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, []);
+			return [];
 		}

-		getSortedSetRank('DESC', keys, values, callback);
+		return await getSortedSetRank('DESC', keys, values);
 	};

-	module.sortedSetRanks = function (key, values, callback) {
+	module.sortedSetRanks = async function (key, values) {
 		if (!Array.isArray(values) || !values.length) {
-			return callback(null, []);
+			return [];
 		}

-		getSortedSetRank('ASC', new Array(values.length).fill(key), values, callback);
+		return await getSortedSetRank('ASC', new Array(values.length).fill(key), values);
 	};

-	module.sortedSetRevRanks = function (key, values, callback) {
+	module.sortedSetRevRanks = async function (key, values) {
 		if (!Array.isArray(values) || !values.length) {
-			return callback(null, []);
+			return [];
 		}

-		getSortedSetRank('DESC', new Array(values.length).fill(key), values, callback);
+		return await getSortedSetRank('DESC', new Array(values.length).fill(key), values);
 	};

-	module.sortedSetScore = function (key, value, callback) {
+	module.sortedSetScore = async function (key, value) {
 		if (!key) {
-			return callback(null, null);
+			return null;
 		}

 		value = helpers.valueToString(value);

-		query({
+		const res = await query({
 			name: 'sortedSetScore',
 			text: `
 SELECT z."score" s
@@ -365,27 +321,21 @@ SELECT z."score" s
 WHERE o."_key" = $1::TEXT
   AND z."value" = $2::TEXT`,
 			values: [key, value],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (res.rows.length) {
-				return callback(null, parseFloat(res.rows[0].s));
-			}
-
-			callback(null, null);
 		});
+		if (res.rows.length) {
+			return parseFloat(res.rows[0].s);
+		}
+		return null;
 	};

-	module.sortedSetsScore = function (keys, value, callback) {
+	module.sortedSetsScore = async function (keys, value) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, []);
+			return [];
 		}

 		value = helpers.valueToString(value);

-		query({
+		const res = await query({
 			name: 'sortedSetsScore',
 			text: `
 SELECT o."_key" k,
@@ -397,31 +347,24 @@ SELECT o."_key" k,
 WHERE o."_key" = ANY($1::TEXT[])
   AND z."value" = $2::TEXT`,
 			values: [keys, value],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, keys.map(function (k) {
-				var s = res.rows.find(function (r) {
-					return r.k === k;
-				});
-
-				return s ? parseFloat(s.s) : null;
-			}));
+		return keys.map(function (k) {
+			var s = res.rows.find(r => r.k === k);
+			return s ? parseFloat(s.s) : null;
 		});
 	};

-	module.sortedSetScores = function (key, values, callback) {
+	module.sortedSetScores = async function (key, values) {
 		if (!key) {
-			return setImmediate(callback, null, null);
+			return null;
 		}
 		if (!values.length) {
-			return setImmediate(callback, null, []);
+			return [];
 		}
 		values = values.map(helpers.valueToString);

-		query({
+		const res = await query({
 			name: 'sortedSetScores',
 			text: `
 SELECT z."value" v,
@@ -433,29 +376,22 @@ SELECT z."value" v,
 WHERE o."_key" = $1::TEXT
   AND z."value" = ANY($2::TEXT[])`,
 			values: [key, values],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, values.map(function (v) {
-				var s = res.rows.find(function (r) {
-					return r.v === v;
-				});
-
-				return s ? parseFloat(s.s) : null;
-			}));
+		return values.map(function (v) {
+			var s = res.rows.find(r => r.v === v);
+			return s ? parseFloat(s.s) : null;
 		});
 	};

-	module.isSortedSetMember = function (key, value, callback) {
+	module.isSortedSetMember = async function (key, value) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		value = helpers.valueToString(value);

-		query({
+		const res = await query({
 			name: 'isSortedSetMember',
 			text: `
 SELECT 1
@@ -466,23 +402,19 @@ SELECT 1
 WHERE o."_key" = $1::TEXT
   AND z."value" = $2::TEXT`,
 			values: [key, value],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, !!res.rows.length);
 		});
+
+		return !!res.rows.length;
 	};

-	module.isSortedSetMembers = function (key, values, callback) {
+	module.isSortedSetMembers = async function (key, values) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		values = values.map(helpers.valueToString);

-		query({
+		const res = await query({
 			name: 'isSortedSetMembers',
 			text: `
 SELECT z."value" v
@@ -493,27 +425,21 @@ SELECT z."value" v
 WHERE o."_key" = $1::TEXT
   AND z."value" = ANY($2::TEXT[])`,
 			values: [key, values],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, values.map(function (v) {
-				return res.rows.some(function (r) {
-					return r.v === v;
-				});
-			}));
+		return values.map(function (v) {
+			return res.rows.some(r => r.v === v);
 		});
 	};

-	module.isMemberOfSortedSets = function (keys, value, callback) {
+	module.isMemberOfSortedSets = async function (keys, value) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return setImmediate(callback, null, []);
+			return [];
 		}

 		value = helpers.valueToString(value);

-		query({
+		const res = await query({
 			name: 'isMemberOfSortedSets',
 			text: `
 SELECT o."_key" k
@@ -524,25 +450,19 @@ SELECT o."_key" k
 WHERE o."_key" = ANY($1::TEXT[])
   AND z."value" = $2::TEXT`,
 			values: [keys, value],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, keys.map(function (k) {
-				return res.rows.some(function (r) {
-					return r.k === k;
-				});
-			}));
+		return keys.map(function (k) {
+			return res.rows.some(r => r.k === k);
 		});
 	};

-	module.getSortedSetsMembers = function (keys, callback) {
+	module.getSortedSetsMembers = async function (keys) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, []);
+			return [];
 		}

-		query({
+		const res = await query({
 			name: 'getSortedSetsMembers',
 			text: `
 SELECT o."_key" k,
@@ -554,61 +474,50 @@ SELECT o."_key" k,
 WHERE o."_key" = ANY($1::TEXT[])
 GROUP BY o."_key"`,
 			values: [keys],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
+		});

-			callback(null, keys.map(function (k) {
-				return (res.rows.find(function (r) {
-					return r.k === k;
-				}) || { m: [] }).m;
-			}));
+		return keys.map(function (k) {
+			return (res.rows.find(r => r.k === k) || { m: [] }).m;
 		});
 	};

-	module.sortedSetIncrBy = function (key, increment, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.sortedSetIncrBy = async function (key, increment, value) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		value = helpers.valueToString(value);
 		increment = parseFloat(increment);

-		module.transaction(function (tx, done) {
-			async.waterfall([
-				async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'zset'),
-				async.apply(tx.client.query.bind(tx.client), {
-					name: 'sortedSetIncrBy',
-					text: `
+		return await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectType(client, key, 'zset');
+			const res = await query({
+				name: 'sortedSetIncrBy',
+				text: `
 INSERT INTO "legacy_zset" ("_key", "value", "score")
 VALUES ($1::TEXT, $2::TEXT, $3::NUMERIC)
-    ON CONFLICT ("_key", "value")
-    DO UPDATE SET "score" = "legacy_zset"."score" + $3::NUMERIC
+ON CONFLICT ("_key", "value")
+DO UPDATE SET "score" = "legacy_zset"."score" + $3::NUMERIC
 RETURNING "score" s`,
-					values: [key, value, increment],
-				}),
-				function (res, next) {
-					next(null, parseFloat(res.rows[0].s));
-				},
-			], done);
-		}, callback);
+				values: [key, value, increment],
+			});
+			return parseFloat(res.rows[0].s);
+		});
 	};

-	module.getSortedSetRangeByLex = function (key, min, max, start, count, callback) {
-		sortedSetLex(key, min, max, 1, start, count, callback);
+	module.getSortedSetRangeByLex = async function (key, min, max, start, count) {
+		return await sortedSetLex(key, min, max, 1, start, count);
 	};

-	module.getSortedSetRevRangeByLex = function (key, max, min, start, count, callback) {
-		sortedSetLex(key, min, max, -1, start, count, callback);
+	module.getSortedSetRevRangeByLex = async function (key, max, min, start, count) {
+		return await sortedSetLex(key, min, max, -1, start, count);
 	};

-	module.sortedSetLexCount = function (key, min, max, callback) {
+	module.sortedSetLexCount = async function (key, min, max) {
 		var q = buildLexQuery(key, min, max);

-		query({
+		const res = await query({
 			name: 'sortedSetLexCount' + q.suffix,
 			text: `
 SELECT COUNT(*) c
@@ -618,26 +527,19 @@ SELECT COUNT(*) c
        AND o."type" = z."type"
 WHERE ` + q.where,
 			values: q.values,
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, parseInt(res.rows[0].c, 10));
 		});
+
+		return parseInt(res.rows[0].c, 10);
 	};

-	function sortedSetLex(key, min, max, sort, start, count, callback) {
-		if (!callback) {
-			callback = start;
-			start = 0;
-			count = 0;
-		}
+	async function sortedSetLex(key, min, max, sort, start, count) {
+		start = start !== undefined ? start : 0;
+		count = count !== undefined ? count : 0;

 		var q = buildLexQuery(key, min, max);
 		q.values.push(start);
 		q.values.push(count <= 0 ? null : count);
-		query({
+		const res = await query({
 			name: 'sortedSetLex' + (sort > 0 ? 'Asc' : 'Desc') + q.suffix,
 			text: `
 SELECT z."value" v
@@ -650,22 +552,14 @@ SELECT z."value" v
 LIMIT $` + q.values.length + `::INTEGER
 OFFSET $` + (q.values.length - 1) + `::INTEGER`,
 			values: q.values,
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, res.rows.map(function (r) {
-				return r.v;
-			}));
 		});
+
+		return res.rows.map(r => r.v);
 	}

-	module.sortedSetRemoveRangeByLex = function (key, min, max, callback) {
-		callback = callback || helpers.noop;
-
+	module.sortedSetRemoveRangeByLex = async function (key, min, max) {
 		var q = buildLexQuery(key, min, max);
-		query({
+		await query({
 			name: 'sortedSetRemoveRangeByLex' + q.suffix,
 			text: `
 DELETE FROM "legacy_zset" z
@@ -674,8 +568,6 @@ DELETE FROM "legacy_zset" z
   AND o."type" = z."type"
   AND ` + q.where,
 			values: q.values,
-		}, function (err) {
-			callback(err);
 		});
 	};

@@ -721,16 +613,10 @@ DELETE FROM "legacy_zset" z
 		return q;
 	}

-	module.processSortedSet = function (setKey, process, options, callback) {
-		var Cursor = require('pg-cursor');
-
-		db.connect(function (err, client, done) {
-			if (err) {
-				return callback(err);
-			}
-
-			var batchSize = (options || {}).batch || 100;
-			var query = client.query(new Cursor(`
+	module.processSortedSet = async function (setKey, process, options) {
+		const client = await db.connect();
+		var batchSize = (options || {}).batch || 100;
+		var cursor = client.query(new Cursor(`
 SELECT z."value", z."score"
  FROM "legacy_object_live" o
 INNER JOIN "legacy_zset" z
@@ -739,43 +625,32 @@ SELECT z."value", z."score"
 WHERE o."_key" = $1::TEXT
 ORDER BY z."score" ASC, z."value" ASC`, [setKey]));

-			var isDone = false;
+		if (process && process.constructor && process.constructor.name !== 'AsyncFunction') {
+			process = util.promisify(process);
+		}

-			async.whilst(function (next) {
-				next(null, !isDone);
-			}, function (next) {
-				query.read(batchSize, function (err, rows) {
-					if (err) {
-						return next(err);
-					}
+		while (true) {
+			/* eslint-disable no-await-in-loop */
+			let rows = await cursor.readAsync(batchSize);
+			if (!rows.length) {
+				client.release();
+				return;
+			}

-					if (!rows.length) {
-						isDone = true;
-						return next();
-					}
-
-					rows = rows.map(function (row) {
-						return options.withScores ? row : row.value;
-					});
-
-					process(rows, function (err) {
-						if (err) {
-							return query.close(function () {
-								next(err);
-							});
-						}
-
-						if (options.interval) {
-							setTimeout(next, options.interval);
-						} else {
-							next();
-						}
-					});
-				});
-			}, function (err) {
-				done();
-				callback(err);
-			});
-		});
+			if (options.withScores) {
+				rows = rows.map(r => ({ value: r.value, score: parseFloat(r.score) }));
+			} else {
+				rows = rows.map(r => r.value);
+			}
+			try {
+				await process(rows);
+			} catch (err) {
+				await query.close();
+				throw err;
+			}
+			if (options.interval) {
+				await sleep(options.interval);
+			}
+		}
 	};
 };
--- a/src/database/postgres/sorted/add.js
+++ b/src/database/postgres/sorted/add.js
@@ -1,134 +1,112 @@
 'use strict';

-var async = require('async');
-
 module.exports = function (db, module) {
-	var helpers = module.helpers.postgres;
+	var helpers = require('../helpers');
 	var utils = require('../../../utils');

-	module.sortedSetAdd = function (key, score, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.sortedSetAdd = async function (key, score, value) {
 		if (!key) {
-			return callback();
+			return;
 		}

 		if (Array.isArray(score) && Array.isArray(value)) {
-			return sortedSetAddBulk(key, score, value, callback);
+			return await sortedSetAddBulk(key, score, value);
 		}
 		if (!utils.isNumber(score)) {
-			return setImmediate(callback, new Error('[[error:invalid-score, ' + score + ']]'));
+			throw new Error('[[error:invalid-score, ' + score + ']]');
 		}
 		value = helpers.valueToString(value);
 		score = parseFloat(score);

-		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, 'zset'),
-				async.apply(query, {
-					name: 'sortedSetAdd',
-					text: `
-INSERT INTO "legacy_zset" ("_key", "value", "score")
-VALUES ($1::TEXT, $2::TEXT, $3::NUMERIC)
-    ON CONFLICT ("_key", "value")
-    DO UPDATE SET "score" = $3::NUMERIC`,
-					values: [key, value, score],
-				}),
-			], function (err) {
-				done(err);
+			await helpers.ensureLegacyObjectType(client, key, 'zset');
+			await query({
+				name: 'sortedSetAdd',
+				text: `
+	INSERT INTO "legacy_zset" ("_key", "value", "score")
+	VALUES ($1::TEXT, $2::TEXT, $3::NUMERIC)
+	ON CONFLICT ("_key", "value")
+	DO UPDATE SET "score" = $3::NUMERIC`,
+				values: [key, value, score],
 			});
-		}, callback);
+		});
 	};

-	function sortedSetAddBulk(key, scores, values, callback) {
+	async function sortedSetAddBulk(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] + ']]');
 			}
 		}
 		values = values.map(helpers.valueToString);
-		scores = scores.map(function (score) {
-			return parseFloat(score);
-		});
+		scores = scores.map(score => parseFloat(score));

 		helpers.removeDuplicateValues(values, scores);

-		module.transaction(function (tx, done) {
-			var query = tx.client.query.bind(tx.client);
-
-			async.series([
-				async.apply(helpers.ensureLegacyObjectType, tx.client, key, 'zset'),
-				async.apply(query, {
-					name: 'sortedSetAddBulk',
-					text: `
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectType(client, key, 'zset');
+			await query({
+				name: 'sortedSetAddBulk',
+				text: `
 INSERT INTO "legacy_zset" ("_key", "value", "score")
 SELECT $1::TEXT, v, s
-  FROM UNNEST($2::TEXT[], $3::NUMERIC[]) vs(v, s)
-    ON CONFLICT ("_key", "value")
-    DO UPDATE SET "score" = EXCLUDED."score"`,
-					values: [key, values, scores],
-				}),
-			], function (err) {
-				done(err);
+FROM UNNEST($2::TEXT[], $3::NUMERIC[]) vs(v, s)
+ON CONFLICT ("_key", "value")
+DO UPDATE SET "score" = EXCLUDED."score"`,
+				values: [key, values, scores],
 			});
-		}, callback);
+		});
 	}

-	module.sortedSetsAdd = function (keys, scores, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.sortedSetsAdd = async function (keys, scores, value) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return 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]]');
 		}

 		value = helpers.valueToString(value);
 		scores = isArrayOfScores ? scores.map(score => parseFloat(score)) : parseFloat(scores);

-		module.transaction(function (tx, done) {
-			var query = tx.client.query.bind(tx.client);
-
-			async.series([
-				async.apply(helpers.ensureLegacyObjectsType, tx.client, keys, 'zset'),
-				async.apply(query, {
-					name: isArrayOfScores ? 'sortedSetsAddScores' : 'sortedSetsAdd',
-					text: isArrayOfScores ? `
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectsType(client, keys, 'zset');
+			await query({
+				name: isArrayOfScores ? 'sortedSetsAddScores' : 'sortedSetsAdd',
+				text: isArrayOfScores ? `
 INSERT INTO "legacy_zset" ("_key", "value", "score")
 SELECT k, $2::TEXT, s
-  FROM UNNEST($1::TEXT[], $3::NUMERIC[]) vs(k, s)
-    ON CONFLICT ("_key", "value")
-		DO UPDATE SET "score" = EXCLUDED."score"` : `
+FROM UNNEST($1::TEXT[], $3::NUMERIC[]) vs(k, s)
+ON CONFLICT ("_key", "value")
+	DO UPDATE SET "score" = EXCLUDED."score"` : `
 INSERT INTO "legacy_zset" ("_key", "value", "score")
-		SELECT k, $2::TEXT, $3::NUMERIC
-			FROM UNNEST($1::TEXT[]) k
-				ON CONFLICT ("_key", "value")
-				DO UPDATE SET "score" = $3::NUMERIC`,
-					values: [keys, value, scores],
-				}),
-			], function (err) {
-				done(err);
+	SELECT k, $2::TEXT, $3::NUMERIC
+		FROM UNNEST($1::TEXT[]) k
+			ON CONFLICT ("_key", "value")
+			DO UPDATE SET "score" = $3::NUMERIC`,
+				values: [keys, value, scores],
 			});
-		}, callback);
+		});
 	};

-	module.sortedSetAddBulk = function (data, callback) {
+	module.sortedSetAddBulk = async function (data) {
 		if (!Array.isArray(data) || !data.length) {
-			return setImmediate(callback);
+			return;
 		}
 		const keys = [];
 		const values = [];
@@ -138,24 +116,19 @@ INSERT INTO "legacy_zset" ("_key", "value", "score")
 			scores.push(item[1]);
 			values.push(item[2]);
 		});
-		module.transaction(function (tx, done) {
-			var query = tx.client.query.bind(tx.client);
-
-			async.series([
-				async.apply(helpers.ensureLegacyObjectsType, tx.client, keys, 'zset'),
-				async.apply(query, {
-					name: 'sortedSetAddBulk2',
-					text: `
+		await module.transaction(async function (client) {
+			var query = client.query.bind(client);
+			await helpers.ensureLegacyObjectsType(client, keys, 'zset');
+			await query({
+				name: 'sortedSetAddBulk2',
+				text: `
 INSERT INTO "legacy_zset" ("_key", "value", "score")
 SELECT k, v, s
-  FROM UNNEST($1::TEXT[], $2::TEXT[], $3::NUMERIC[]) vs(k, v, s)
-    ON CONFLICT ("_key", "value")
-    DO UPDATE SET "score" = EXCLUDED."score"`,
-					values: [keys, values, scores],
-				}),
-			], function (err) {
-				done(err);
+FROM UNNEST($1::TEXT[], $2::TEXT[], $3::NUMERIC[]) vs(k, v, s)
+ON CONFLICT ("_key", "value")
+DO UPDATE SET "score" = EXCLUDED."score"`,
+				values: [keys, values, scores],
 			});
-		}, callback);
+		});
 	};
 };
--- a/src/database/postgres/sorted/intersect.js
+++ b/src/database/postgres/sorted/intersect.js
@@ -1,12 +1,12 @@
 'use strict';

 module.exports = function (db, module) {
-	module.sortedSetIntersectCard = function (keys, callback) {
+	module.sortedSetIntersectCard = async function (keys) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, 0);
+			return 0;
 		}

-		db.query({
+		const res = await db.query({
 			name: 'sortedSetIntersectCard',
 			text: `
 WITH A AS (SELECT z."value" v,
@@ -21,27 +21,22 @@ SELECT COUNT(*) c
  FROM A
 WHERE A.c = array_length($1::TEXT[], 1)`,
 			values: [keys],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, parseInt(res.rows[0].c, 10));
 		});
+
+		return parseInt(res.rows[0].c, 10);
 	};

-
-	module.getSortedSetIntersect = function (params, callback) {
+	module.getSortedSetIntersect = async function (params) {
 		params.sort = 1;
-		getSortedSetIntersect(params, callback);
+		return await getSortedSetIntersect(params);
 	};

-	module.getSortedSetRevIntersect = function (params, callback) {
+	module.getSortedSetRevIntersect = async function (params) {
 		params.sort = -1;
-		getSortedSetIntersect(params, callback);
+		return await getSortedSetIntersect(params);
 	};

-	function getSortedSetIntersect(params, callback) {
+	async function getSortedSetIntersect(params) {
 		var sets = params.sets;
 		var start = params.hasOwnProperty('start') ? params.start : 0;
 		var stop = params.hasOwnProperty('stop') ? params.stop : -1;
@@ -60,7 +55,7 @@ SELECT COUNT(*) c
 			limit = null;
 		}

-		db.query({
+		const res = await db.query({
 			name: 'getSortedSetIntersect' + aggregate + (params.sort > 0 ? 'Asc' : 'Desc') + 'WithScores',
 			text: `
 WITH A AS (SELECT z."value",
@@ -81,25 +76,19 @@ SELECT A."value",
 LIMIT $4::INTEGER
 OFFSET $3::INTEGER`,
 			values: [sets, weights, start, limit],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (params.withScores) {
-				res.rows = res.rows.map(function (r) {
-					return {
-						value: r.value,
-						score: parseFloat(r.score),
-					};
-				});
-			} else {
-				res.rows = res.rows.map(function (r) {
-					return r.value;
-				});
-			}
-
-			callback(null, res.rows);
 		});
+
+		if (params.withScores) {
+			res.rows = res.rows.map(function (r) {
+				return {
+					value: r.value,
+					score: parseFloat(r.score),
+				};
+			});
+		} else {
+			res.rows = res.rows.map(r => r.value);
+		}
+
+		return res.rows;
 	}
 };
--- a/src/database/postgres/sorted/remove.js
+++ b/src/database/postgres/sorted/remove.js
@@ -1,64 +1,55 @@
 'use strict';

 module.exports = function (db, module) {
-	var helpers = module.helpers.postgres;
-
-	module.sortedSetRemove = function (key, value, callback) {
-		function done(err) {
-			if (callback) {
-				callback(err);
-			}
-		}
+	var helpers = require('../helpers');

+	module.sortedSetRemove = async function (key, value) {
 		if (!key) {
-			return done();
+			return;
+		}
+		const isValueArray = Array.isArray(value);
+		if (!value || (isValueArray && !value.length)) {
+			return;
 		}

 		if (!Array.isArray(key)) {
 			key = [key];
 		}

-		if (!Array.isArray(value)) {
+		if (!isValueArray) {
 			value = [value];
 		}
 		value = value.map(helpers.valueToString);
-
-		db.query({
+		await db.query({
 			name: 'sortedSetRemove',
 			text: `
 DELETE FROM "legacy_zset"
 WHERE "_key" = ANY($1::TEXT[])
   AND "value" = ANY($2::TEXT[])`,
 			values: [key, value],
-		}, done);
+		});
 	};

-	module.sortedSetsRemove = function (keys, value, callback) {
-		callback = callback || helpers.noop;
-
+	module.sortedSetsRemove = async function (keys, value) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback();
+			return;
 		}

 		value = helpers.valueToString(value);

-		db.query({
+		await db.query({
 			name: 'sortedSetsRemove',
 			text: `
 DELETE FROM "legacy_zset"
 WHERE "_key" = ANY($1::TEXT[])
   AND "value" = $2::TEXT`,
 			values: [keys, value],
-		}, function (err) {
-			callback(err);
 		});
 	};

-	module.sortedSetsRemoveRangeByScore = function (keys, min, max, callback) {
-		callback = callback || helpers.noop;
-
+	module.sortedSetsRemoveRangeByScore = async function (keys, min, max) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback();
+			return;
 		}

 		if (min === '-inf') {
@@ -68,7 +59,7 @@ DELETE FROM "legacy_zset"
 			max = null;
 		}

-		db.query({
+		await db.query({
 			name: 'sortedSetsRemoveRangeByScore',
 			text: `
 DELETE FROM "legacy_zset"
@@ -76,8 +67,6 @@ DELETE FROM "legacy_zset"
   AND ("score" >= $2::NUMERIC OR $2::NUMERIC IS NULL)
   AND ("score" <= $3::NUMERIC OR $3::NUMERIC IS NULL)`,
 			values: [keys, min, max],
-		}, function (err) {
-			callback(err);
 		});
 	};
 };
--- a/src/database/postgres/sorted/union.js
+++ b/src/database/postgres/sorted/union.js
@@ -1,12 +1,12 @@
 'use strict';

 module.exports = function (db, module) {
-	module.sortedSetUnionCard = function (keys, callback) {
+	module.sortedSetUnionCard = async function (keys) {
 		if (!Array.isArray(keys) || !keys.length) {
-			return callback(null, 0);
+			return 0;
 		}

-		db.query({
+		const res = await db.query({
 			name: 'sortedSetUnionCard',
 			text: `
 SELECT COUNT(DISTINCT z."value") c
@@ -16,26 +16,21 @@ SELECT COUNT(DISTINCT z."value") c
        AND o."type" = z."type"
 WHERE o."_key" = ANY($1::TEXT[])`,
 			values: [keys],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			callback(null, parseInt(res.rows[0].c, 10));
 		});
+		return res.rows[0].c;
 	};

-	module.getSortedSetUnion = function (params, callback) {
+	module.getSortedSetUnion = async function (params) {
 		params.sort = 1;
-		getSortedSetUnion(params, callback);
+		return await getSortedSetUnion(params);
 	};

-	module.getSortedSetRevUnion = function (params, callback) {
+	module.getSortedSetRevUnion = async function (params) {
 		params.sort = -1;
-		getSortedSetUnion(params, callback);
+		return await getSortedSetUnion(params);
 	};

-	function getSortedSetUnion(params, callback) {
+	async function getSortedSetUnion(params) {
 		var sets = params.sets;
 		var start = params.hasOwnProperty('start') ? params.start : 0;
 		var stop = params.hasOwnProperty('stop') ? params.stop : -1;
@@ -54,7 +49,7 @@ SELECT COUNT(DISTINCT z."value") c
 			limit = null;
 		}

-		db.query({
+		const res = await db.query({
 			name: 'getSortedSetUnion' + aggregate + (params.sort > 0 ? 'Asc' : 'Desc') + 'WithScores',
 			text: `
 WITH A AS (SELECT z."value",
@@ -73,25 +68,18 @@ SELECT A."value",
 LIMIT $4::INTEGER
 OFFSET $3::INTEGER`,
 			values: [sets, weights, start, limit],
-		}, function (err, res) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (params.withScores) {
-				res.rows = res.rows.map(function (r) {
-					return {
-						value: r.value,
-						score: parseFloat(r.score),
-					};
-				});
-			} else {
-				res.rows = res.rows.map(function (r) {
-					return r.value;
-				});
-			}
-
-			callback(null, res.rows);
 		});
+
+		if (params.withScores) {
+			res.rows = res.rows.map(function (r) {
+				return {
+					value: r.value,
+					score: parseFloat(r.score),
+				};
+			});
+		} else {
+			res.rows = res.rows.map(r => r.value);
+		}
+		return res.rows;
 	}
 };
--- a/src/database/postgres/transaction.js
+++ b/src/database/postgres/transaction.js
@@ -1,50 +1,32 @@
 'use strict';

-module.exports = function (db, dbNamespace, module) {
-	module.transaction = function (perform, callback) {
-		if (dbNamespace.active && dbNamespace.get('db')) {
-			var client = dbNamespace.get('db');
-			return client.query(`SAVEPOINT nodebb_subtx`, function (err) {
-				if (err) {
-					return callback(err);
-				}
-
-				perform(module, function (err) {
-					var args = Array.prototype.slice.call(arguments, 1);
-
-					client.query(err ? `ROLLBACK TO SAVEPOINT nodebb_subtx` : `RELEASE SAVEPOINT nodebb_subtx`, function (err1) {
-						callback.apply(this, [err || err1].concat(args));
-					});
-				});
-			});
-		}
-
-		db.connect(function (err, client, done) {
-			if (err) {
-				return callback(err);
+module.exports = function (db, module) {
+	module.transaction = async function (perform, txClient) {
+		let res;
+		if (txClient) {
+			await txClient.query(`SAVEPOINT nodebb_subtx`);
+			try {
+				res = await perform(txClient);
+			} catch (err) {
+				await txClient.query(`ROLLBACK TO SAVEPOINT nodebb_subtx`);
+				throw err;
 			}
+			await txClient.query(`RELEASE SAVEPOINT nodebb_subtx`);
+			return res;
+		}
+		// see https://node-postgres.com/features/transactions#a-pooled-client-with-async-await
+		const client = await db.connect();

-			dbNamespace.run(function () {
-				dbNamespace.set('db', client);
-
-				client.query(`BEGIN`, function (err) {
-					if (err) {
-						done();
-						dbNamespace.set('db', null);
-						return callback(err);
-					}
-
-					perform(module, function (err) {
-						var args = Array.prototype.slice.call(arguments, 1);
-
-						client.query(err ? `ROLLBACK` : `COMMIT`, function (err1) {
-							done();
-							dbNamespace.set('db', null);
-							callback.apply(this, [err || err1].concat(args));
-						});
-					});
-				});
-			});
-		});
+		try {
+			await client.query('BEGIN');
+			res = await perform(client);
+			await client.query('COMMIT');
+		} catch (err) {
+			await client.query('ROLLBACK');
+			throw err;
+		} finally {
+			client.release();
+		}
+		return res;
 	};
 };