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,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;
};
};