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
This commit is contained in:
Barış Soner Uşaklı
2019-07-09 12:46:49 -04:00
committed by GitHub
parent 43ce5f8af3
commit 805dcd7ca2
73 changed files with 4030 additions and 6110 deletions

View File

@@ -1,33 +1,28 @@
'use strict';
module.exports = function (redisClient, module) {
var helpers = module.helpers.redis;
var helpers = require('./helpers');
module.setAdd = function (key, value, callback) {
callback = callback || function () {};
module.setAdd = async function (key, value) {
if (!Array.isArray(value)) {
value = [value];
}
if (!value.length) {
return callback();
return;
}
redisClient.sadd(key, value, function (err) {
callback(err);
});
await redisClient.async.sadd(key, value);
};
module.setsAdd = function (keys, value, callback) {
callback = callback || function () {};
module.setsAdd = async function (keys, value) {
if (!Array.isArray(keys) || !keys.length) {
return setImmediate(callback);
return;
}
helpers.execKeysValue(redisClient, 'batch', 'sadd', keys, value, function (err) {
callback(err);
});
const batch = redisClient.batch();
keys.forEach(k => batch.sadd(String(k), String(value)));
await helpers.execBatch(batch);
};
module.setRemove = function (key, value, callback) {
callback = callback || function () {};
module.setRemove = async function (key, value) {
if (!Array.isArray(value)) {
value = [value];
}
@@ -36,58 +31,57 @@ module.exports = function (redisClient, module) {
}
var batch = redisClient.batch();
key.forEach(function (key) {
batch.srem(key, value);
});
batch.exec(function (err) {
callback(err);
});
key.forEach(k => batch.srem(String(k), value));
await helpers.execBatch(batch);
};
module.setsRemove = function (keys, value, callback) {
callback = callback || function () {};
helpers.execKeysValue(redisClient, 'batch', 'srem', keys, value, function (err) {
callback(err);
});
module.setsRemove = async function (keys, value) {
var batch = redisClient.batch();
keys.forEach(k => batch.srem(String(k), value));
await helpers.execBatch(batch);
};
module.isSetMember = function (key, value, callback) {
redisClient.sismember(key, value, function (err, result) {
callback(err, result === 1);
});
module.isSetMember = async function (key, value) {
const result = await redisClient.async.sismember(key, value);
return result === 1;
};
module.isSetMembers = function (key, values, callback) {
helpers.execKeyValues(redisClient, 'batch', 'sismember', key, values, function (err, results) {
callback(err, results ? helpers.resultsToBool(results) : null);
});
module.isSetMembers = async function (key, values) {
const batch = redisClient.batch();
values.forEach(v => batch.sismember(String(key), String(v)));
const results = await helpers.execBatch(batch);
return results ? helpers.resultsToBool(results) : null;
};
module.isMemberOfSets = function (sets, value, callback) {
helpers.execKeysValue(redisClient, 'batch', 'sismember', sets, value, function (err, results) {
callback(err, results ? helpers.resultsToBool(results) : null);
});
module.isMemberOfSets = async function (sets, value) {
const batch = redisClient.batch();
sets.forEach(s => batch.sismember(String(s), String(value)));
const results = await helpers.execBatch(batch);
return results ? helpers.resultsToBool(results) : null;
};
module.getSetMembers = function (key, callback) {
redisClient.smembers(key, callback);
module.getSetMembers = async function (key) {
return await redisClient.async.smembers(key);
};
module.getSetsMembers = function (keys, callback) {
helpers.execKeys(redisClient, 'batch', 'smembers', keys, callback);
module.getSetsMembers = async function (keys) {
const batch = redisClient.batch();
keys.forEach(k => batch.smembers(String(k)));
return await helpers.execBatch(batch);
};
module.setCount = function (key, callback) {
redisClient.scard(key, callback);
module.setCount = async function (key) {
return await redisClient.async.scard(key);
};
module.setsCount = function (keys, callback) {
helpers.execKeys(redisClient, 'batch', 'scard', keys, callback);
module.setsCount = async function (keys) {
const batch = redisClient.batch();
keys.forEach(k => batch.scard(String(k)));
return await helpers.execBatch(batch);
};
module.setRemoveRandom = function (key, callback) {
callback = callback || function () {};
redisClient.spop(key, callback);
module.setRemoveRandom = async function (key) {
return await redisClient.async.spop(key);
};
return module;