mirror of
https://github.com/NodeBB/NodeBB.git
synced 2026-05-06 05:37:53 +02:00
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ı
committed by
GitHub
GitHub
parent
43ce5f8af3
commit
805dcd7ca2
@@ -1,86 +1,73 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
var _ = require('lodash');
|
||||
const cache = require('../cache').create('mongo');
|
||||
|
||||
module.objectCache = cache;
|
||||
|
||||
module.setObject = function (key, data, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.setObject = async function (key, data) {
|
||||
if (!key || !data) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
const writeData = helpers.serializeData(data);
|
||||
db.collection('objects').updateOne({ _key: key }, { $set: writeData }, { upsert: true, w: 1 }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
callback();
|
||||
});
|
||||
await db.collection('objects').updateOne({ _key: key }, { $set: writeData }, { upsert: true, w: 1 });
|
||||
cache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.setObjectField = function (key, field, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.setObjectField = async function (key, field, value) {
|
||||
if (!field) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
var data = {};
|
||||
data[field] = value;
|
||||
module.setObject(key, data, callback);
|
||||
await module.setObject(key, data);
|
||||
};
|
||||
|
||||
module.getObject = function (key, callback) {
|
||||
module.getObject = async function (key) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
|
||||
module.getObjects([key], function (err, data) {
|
||||
callback(err, data && data.length ? data[0] : null);
|
||||
});
|
||||
const data = await module.getObjects([key]);
|
||||
return data && data.length ? data[0] : null;
|
||||
};
|
||||
|
||||
module.getObjects = function (keys, callback) {
|
||||
module.getObjectsFields(keys, [], callback);
|
||||
module.getObjects = async function (keys) {
|
||||
return await module.getObjectsFields(keys, []);
|
||||
};
|
||||
|
||||
module.getObjectField = function (key, field, callback) {
|
||||
module.getObjectField = async function (key, field) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
return null;
|
||||
}
|
||||
const cachedData = {};
|
||||
cache.getUnCachedKeys([key], cachedData);
|
||||
if (cachedData[key]) {
|
||||
return setImmediate(callback, null, cachedData[key].hasOwnProperty(field) ? cachedData[key][field] : null);
|
||||
return cachedData[key].hasOwnProperty(field) ? cachedData[key][field] : null;
|
||||
}
|
||||
field = helpers.fieldToString(field);
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, [field]: 1 } }, function (err, item) {
|
||||
if (err || !item) {
|
||||
return callback(err, null);
|
||||
}
|
||||
callback(null, item.hasOwnProperty(field) ? item[field] : null);
|
||||
});
|
||||
};
|
||||
|
||||
module.getObjectFields = function (key, fields, callback) {
|
||||
if (!key) {
|
||||
return setImmediate(callback, null, null);
|
||||
const item = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, [field]: 1 } });
|
||||
if (!item) {
|
||||
return null;
|
||||
}
|
||||
module.getObjectsFields([key], fields, function (err, data) {
|
||||
callback(err, data ? data[0] : null);
|
||||
});
|
||||
return item.hasOwnProperty(field) ? item[field] : null;
|
||||
};
|
||||
|
||||
module.getObjectsFields = function (keys, fields, callback) {
|
||||
module.getObjectFields = async function (key, fields) {
|
||||
if (!key) {
|
||||
return null;
|
||||
}
|
||||
const data = await module.getObjectsFields([key], fields);
|
||||
return data ? data[0] : null;
|
||||
};
|
||||
|
||||
module.getObjectsFields = async function (keys, fields) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
const cachedData = {};
|
||||
function returnData() {
|
||||
@@ -97,104 +84,72 @@ module.exports = function (db, module) {
|
||||
return result;
|
||||
});
|
||||
|
||||
callback(null, mapped);
|
||||
return mapped;
|
||||
}
|
||||
|
||||
const unCachedKeys = cache.getUnCachedKeys(keys, cachedData);
|
||||
if (!unCachedKeys.length) {
|
||||
return process.nextTick(returnData);
|
||||
return returnData();
|
||||
}
|
||||
|
||||
var query = { _key: { $in: unCachedKeys } };
|
||||
if (unCachedKeys.length === 1) {
|
||||
query._key = unCachedKeys[0];
|
||||
}
|
||||
db.collection('objects').find(query, { projection: { _id: 0 } }).toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
data = data.map(helpers.deserializeData);
|
||||
var map = helpers.toMap(data);
|
||||
unCachedKeys.forEach(function (key) {
|
||||
cachedData[key] = map[key] || null;
|
||||
cache.set(key, cachedData[key]);
|
||||
});
|
||||
let data = await db.collection('objects').find(query, { projection: { _id: 0 } }).toArray();
|
||||
|
||||
returnData();
|
||||
data = data.map(helpers.deserializeData);
|
||||
var map = helpers.toMap(data);
|
||||
unCachedKeys.forEach(function (key) {
|
||||
cachedData[key] = map[key] || null;
|
||||
cache.set(key, cachedData[key]);
|
||||
});
|
||||
|
||||
return returnData();
|
||||
};
|
||||
|
||||
module.getObjectKeys = function (key, callback) {
|
||||
module.getObject(key, function (err, data) {
|
||||
callback(err, data ? Object.keys(data) : []);
|
||||
});
|
||||
module.getObjectKeys = async function (key) {
|
||||
const data = await module.getObject(key);
|
||||
return data ? Object.keys(data) : [];
|
||||
};
|
||||
|
||||
module.getObjectValues = function (key, callback) {
|
||||
module.getObject(key, function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
var values = [];
|
||||
for (var key in data) {
|
||||
if (data && 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) {
|
||||
const data = await module.isObjectFields(key, [field]);
|
||||
return Array.isArray(data) && data.length ? data[0] : false;
|
||||
};
|
||||
|
||||
module.isObjectFields = async function (key, fields) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
}
|
||||
var data = {};
|
||||
field = helpers.fieldToString(field);
|
||||
data[field] = 1;
|
||||
db.collection('objects').findOne({ _key: key }, { projection: data }, function (err, item) {
|
||||
callback(err, !!item && item[field] !== undefined && item[field] !== null);
|
||||
});
|
||||
};
|
||||
|
||||
module.isObjectFields = function (key, fields, callback) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
var data = {};
|
||||
const data = {};
|
||||
fields.forEach(function (field) {
|
||||
field = helpers.fieldToString(field);
|
||||
data[field] = 1;
|
||||
});
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { projection: data }, function (err, item) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
var results = [];
|
||||
|
||||
fields.forEach(function (field, index) {
|
||||
results[index] = !!item && item[field] !== undefined && item[field] !== null;
|
||||
});
|
||||
|
||||
callback(null, results);
|
||||
});
|
||||
const item = await db.collection('objects').findOne({ _key: key }, { projection: data });
|
||||
const results = fields.map(f => !!item && item[f] !== undefined && item[f] !== null);
|
||||
return results;
|
||||
};
|
||||
|
||||
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;
|
||||
}
|
||||
fields = fields.filter(Boolean);
|
||||
if (!fields.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
var data = {};
|
||||
@@ -203,68 +158,41 @@ module.exports = function (db, module) {
|
||||
data[field] = '';
|
||||
});
|
||||
|
||||
db.collection('objects').updateOne({ _key: key }, { $unset: data }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
callback();
|
||||
});
|
||||
await db.collection('objects').updateOne({ _key: key }, { $unset: data });
|
||||
cache.delObjectCache(key);
|
||||
};
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
var data = {};
|
||||
var increment = {};
|
||||
field = helpers.fieldToString(field);
|
||||
data[field] = value;
|
||||
increment[field] = value;
|
||||
|
||||
if (Array.isArray(key)) {
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
key.forEach(function (key) {
|
||||
bulk.find({ _key: key }).upsert().update({ $inc: data });
|
||||
bulk.find({ _key: key }).upsert().update({ $inc: increment });
|
||||
});
|
||||
|
||||
async.waterfall([
|
||||
function (next) {
|
||||
bulk.execute(function (err) {
|
||||
next(err);
|
||||
});
|
||||
},
|
||||
function (next) {
|
||||
cache.delObjectCache(key);
|
||||
|
||||
module.getObjectsFields(key, [field], next);
|
||||
},
|
||||
function (data, next) {
|
||||
data = data.map(function (data) {
|
||||
return data && data[field];
|
||||
});
|
||||
next(null, data);
|
||||
},
|
||||
], callback);
|
||||
return;
|
||||
await bulk.execute();
|
||||
cache.delObjectCache(key);
|
||||
const result = await module.getObjectsFields(key, [field]);
|
||||
return result.map(data => data && data[field]);
|
||||
}
|
||||
|
||||
|
||||
db.collection('objects').findOneAndUpdate({ _key: key }, { $inc: data }, { returnOriginal: false, upsert: true }, function (err, result) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
cache.delObjectCache(key);
|
||||
callback(null, result && result.value ? result.value[field] : null);
|
||||
});
|
||||
const result = await db.collection('objects').findOneAndUpdate({ _key: key }, { $inc: increment }, { returnOriginal: false, upsert: true });
|
||||
cache.delObjectCache(key);
|
||||
return result && result.value ? result.value[field] : null;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,112 +1,75 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
module.isObjectField(key, 'array', function (err, exists) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (exists) {
|
||||
db.collection('objects').updateOne({ _key: key }, { $push: { array: { $each: [value], $position: 0 } } }, { upsert: true, w: 1 }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
} else {
|
||||
module.listAppend(key, value, callback);
|
||||
}
|
||||
});
|
||||
const exists = await module.isObjectField(key, 'array');
|
||||
if (exists) {
|
||||
await db.collection('objects').updateOne({ _key: key }, { $push: { array: { $each: [value], $position: 0 } } }, { upsert: true, w: 1 });
|
||||
} else {
|
||||
await module.listAppend(key, value);
|
||||
}
|
||||
};
|
||||
|
||||
module.listAppend = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.listAppend = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
db.collection('objects').updateOne({ _key: key }, { $push: { array: value } }, { upsert: true, w: 1 }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').updateOne({ _key: key }, { $push: { array: value } }, { upsert: true, w: 1 });
|
||||
};
|
||||
|
||||
module.listRemoveLast = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.listRemoveLast = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
module.getListRange(key, -1, -1, function (err, value) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
db.collection('objects').updateOne({ _key: key }, { $pop: { array: 1 } }, function (err) {
|
||||
callback(err, (value && value.length) ? value[0] : null);
|
||||
});
|
||||
});
|
||||
const value = await module.getListRange(key, -1, -1);
|
||||
db.collection('objects').updateOne({ _key: key }, { $pop: { array: 1 } });
|
||||
return (value && value.length) ? value[0] : null;
|
||||
};
|
||||
|
||||
module.listRemoveAll = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.listRemoveAll = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').updateOne({ _key: key }, { $pull: { array: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').updateOne({ _key: key }, { $pull: { array: value } });
|
||||
};
|
||||
|
||||
module.listTrim = function (key, start, stop, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.listTrim = async function (key, start, stop) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
module.getListRange(key, start, stop, function (err, value) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
db.collection('objects').updateOne({ _key: key }, { $set: { array: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
});
|
||||
const value = await module.getListRange(key, start, stop);
|
||||
await db.collection('objects').updateOne({ _key: key }, { $set: { array: value } });
|
||||
};
|
||||
|
||||
module.getListRange = function (key, start, stop, callback) {
|
||||
module.getListRange = async function (key, start, stop) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { array: 1 }, function (err, data) {
|
||||
if (err || !(data && data.array)) {
|
||||
return callback(err, []);
|
||||
}
|
||||
const data = await db.collection('objects').findOne({ _key: key }, { array: 1 });
|
||||
if (!(data && data.array)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
if (stop === -1) {
|
||||
data.array = data.array.slice(start);
|
||||
} else {
|
||||
data.array = data.array.slice(start, stop + 1);
|
||||
}
|
||||
callback(null, data.array);
|
||||
});
|
||||
return data.array.slice(start, stop !== -1 ? stop + 1 : undefined);
|
||||
};
|
||||
|
||||
module.listLength = function (key, callback) {
|
||||
db.collection('objects').aggregate([
|
||||
module.listLength = async function (key) {
|
||||
const result = await db.collection('objects').aggregate([
|
||||
{ $match: { _key: key } },
|
||||
{ $project: { count: { $size: '$array' } } },
|
||||
]).toArray(function (err, result) {
|
||||
callback(err, Array.isArray(result) && result.length && result[0].count);
|
||||
});
|
||||
]).toArray();
|
||||
return Array.isArray(result) && result.length && result[0].count;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,170 +1,121 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
|
||||
module.flushdb = function (callback) {
|
||||
callback = callback || helpers.noop;
|
||||
db.dropDatabase(function (err) {
|
||||
callback(err);
|
||||
});
|
||||
module.flushdb = async function () {
|
||||
await db.dropDatabase();
|
||||
};
|
||||
|
||||
module.emptydb = function (callback) {
|
||||
callback = callback || helpers.noop;
|
||||
db.collection('objects').deleteMany({}, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
module.objectCache.resetObjectCache();
|
||||
callback();
|
||||
});
|
||||
module.emptydb = async function () {
|
||||
await db.collection('objects').deleteMany({});
|
||||
module.objectCache.resetObjectCache();
|
||||
};
|
||||
|
||||
module.exists = function (key, callback) {
|
||||
module.exists = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
if (Array.isArray(key)) {
|
||||
db.collection('objects').find({ _key: { $in: key } }).toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
var map = {};
|
||||
data.forEach(function (item) {
|
||||
map[item._key] = true;
|
||||
});
|
||||
|
||||
callback(null, key.map(key => !!map[key]));
|
||||
});
|
||||
} else {
|
||||
db.collection('objects').findOne({ _key: key }, function (err, item) {
|
||||
callback(err, item !== undefined && item !== null);
|
||||
const data = await db.collection('objects').find({ _key: { $in: key } }).toArray();
|
||||
var map = {};
|
||||
data.forEach(function (item) {
|
||||
map[item._key] = true;
|
||||
});
|
||||
|
||||
return key.map(key => !!map[key]);
|
||||
}
|
||||
const item = await db.collection('objects').findOne({ _key: key });
|
||||
return item !== undefined && item !== null;
|
||||
};
|
||||
|
||||
module.delete = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.delete = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
db.collection('objects').deleteMany({ _key: key }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
module.objectCache.delObjectCache(key);
|
||||
callback();
|
||||
});
|
||||
await db.collection('objects').deleteMany({ _key: key });
|
||||
module.objectCache.delObjectCache(key);
|
||||
};
|
||||
|
||||
module.deleteAll = function (keys, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.deleteAll = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
db.collection('objects').deleteMany({ _key: { $in: keys } }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
module.objectCache.delObjectCache(keys);
|
||||
|
||||
callback(null);
|
||||
});
|
||||
await db.collection('objects').deleteMany({ _key: { $in: keys } });
|
||||
module.objectCache.delObjectCache(keys);
|
||||
};
|
||||
|
||||
module.get = function (key, callback) {
|
||||
module.get = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0 } }, function (err, objectData) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
const objectData = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0 } });
|
||||
|
||||
// fallback to old field name 'value' for backwards compatibility #6340
|
||||
var value = null;
|
||||
if (objectData) {
|
||||
if (objectData.hasOwnProperty('data')) {
|
||||
value = objectData.data;
|
||||
} else if (objectData.hasOwnProperty('value')) {
|
||||
value = objectData.value;
|
||||
}
|
||||
// fallback to old field name 'value' for backwards compatibility #6340
|
||||
var value = null;
|
||||
if (objectData) {
|
||||
if (objectData.hasOwnProperty('data')) {
|
||||
value = objectData.data;
|
||||
} else if (objectData.hasOwnProperty('value')) {
|
||||
value = objectData.value;
|
||||
}
|
||||
}
|
||||
callback(null, value);
|
||||
});
|
||||
}
|
||||
return value;
|
||||
};
|
||||
|
||||
module.set = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.set = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
var data = { data: value };
|
||||
module.setObject(key, data, callback);
|
||||
await module.setObject(key, data);
|
||||
};
|
||||
|
||||
module.increment = function (key, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.increment = async function (key) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
db.collection('objects').findOneAndUpdate({ _key: key }, { $inc: { data: 1 } }, { returnOriginal: false, upsert: true }, function (err, result) {
|
||||
callback(err, result && result.value ? result.value.data : null);
|
||||
});
|
||||
const result = await db.collection('objects').findOneAndUpdate({ _key: key }, { $inc: { data: 1 } }, { returnOriginal: false, upsert: true });
|
||||
return result && result.value ? result.value.data : null;
|
||||
};
|
||||
|
||||
module.rename = function (oldKey, newKey, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
db.collection('objects').updateMany({ _key: oldKey }, { $set: { _key: newKey } }, function (err) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
module.objectCache.delObjectCache(oldKey);
|
||||
module.objectCache.delObjectCache(newKey);
|
||||
callback();
|
||||
});
|
||||
module.rename = async function (oldKey, newKey) {
|
||||
await db.collection('objects').updateMany({ _key: oldKey }, { $set: { _key: newKey } });
|
||||
module.objectCache.delObjectCache([oldKey, newKey]);
|
||||
};
|
||||
|
||||
module.type = function (key, callback) {
|
||||
db.collection('objects').findOne({ _key: key }, function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
if (!data) {
|
||||
return callback(null, null);
|
||||
}
|
||||
delete data.expireAt;
|
||||
var keys = Object.keys(data);
|
||||
if (keys.length === 4 && data.hasOwnProperty('_key') && data.hasOwnProperty('score') && data.hasOwnProperty('value')) {
|
||||
return callback(null, 'zset');
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('members')) {
|
||||
return callback(null, 'set');
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('array')) {
|
||||
return callback(null, 'list');
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('data')) {
|
||||
return callback(null, 'string');
|
||||
}
|
||||
callback(null, 'hash');
|
||||
});
|
||||
module.type = async function (key) {
|
||||
const data = await db.collection('objects').findOne({ _key: key });
|
||||
if (!data) {
|
||||
return null;
|
||||
}
|
||||
delete data.expireAt;
|
||||
var keys = Object.keys(data);
|
||||
if (keys.length === 4 && data.hasOwnProperty('_key') && data.hasOwnProperty('score') && data.hasOwnProperty('value')) {
|
||||
return 'zset';
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('members')) {
|
||||
return 'set';
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('array')) {
|
||||
return 'list';
|
||||
} else if (keys.length === 3 && data.hasOwnProperty('_key') && data.hasOwnProperty('data')) {
|
||||
return 'string';
|
||||
}
|
||||
return 'hash';
|
||||
};
|
||||
|
||||
module.expire = function (key, seconds, callback) {
|
||||
module.expireAt(key, Math.round(Date.now() / 1000) + seconds, callback);
|
||||
module.expire = async function (key, seconds) {
|
||||
await module.expireAt(key, Math.round(Date.now() / 1000) + seconds);
|
||||
};
|
||||
|
||||
module.expireAt = function (key, timestamp, callback) {
|
||||
module.setObjectField(key, 'expireAt', new Date(timestamp * 1000), callback);
|
||||
module.expireAt = async function (key, timestamp) {
|
||||
await module.setObjectField(key, 'expireAt', new Date(timestamp * 1000));
|
||||
};
|
||||
|
||||
module.pexpire = function (key, ms, callback) {
|
||||
module.pexpireAt(key, Date.now() + parseInt(ms, 10), callback);
|
||||
module.pexpire = async function (key, ms) {
|
||||
await module.pexpireAt(key, Date.now() + parseInt(ms, 10));
|
||||
};
|
||||
|
||||
module.pexpireAt = function (key, timestamp, callback) {
|
||||
module.pexpireAt = async function (key, timestamp) {
|
||||
timestamp = Math.min(timestamp, 8640000000000000);
|
||||
module.setObjectField(key, 'expireAt', new Date(timestamp), callback);
|
||||
await module.setObjectField(key, 'expireAt', new Date(timestamp));
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,19 +1,16 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
var helpers = require('./helpers');
|
||||
|
||||
module.setAdd = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.setAdd = async function (key, value) {
|
||||
if (!Array.isArray(value)) {
|
||||
value = [value];
|
||||
}
|
||||
|
||||
value.forEach(function (element, index, array) {
|
||||
array[index] = helpers.valueToString(element);
|
||||
});
|
||||
value = value.map(v => helpers.valueToString(v));
|
||||
|
||||
db.collection('objects').updateOne({
|
||||
await db.collection('objects').updateOne({
|
||||
_key: key,
|
||||
}, {
|
||||
$addToSet: {
|
||||
@@ -24,25 +21,19 @@ module.exports = function (db, module) {
|
||||
}, {
|
||||
upsert: true,
|
||||
w: 1,
|
||||
}, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
};
|
||||
|
||||
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)) {
|
||||
value = [value];
|
||||
}
|
||||
|
||||
value.forEach(function (element, index, array) {
|
||||
array[index] = helpers.valueToString(element);
|
||||
});
|
||||
value = value.map(v => helpers.valueToString(v));
|
||||
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
|
||||
@@ -53,168 +44,118 @@ module.exports = function (db, module) {
|
||||
},
|
||||
} });
|
||||
}
|
||||
|
||||
bulk.execute(function (err) {
|
||||
try {
|
||||
await bulk.execute();
|
||||
} catch (err) {
|
||||
if (err && err.message.startsWith('E11000 duplicate key error')) {
|
||||
return process.nextTick(module.setsAdd, keys, value, callback);
|
||||
return await module.setsAdd(keys, value);
|
||||
}
|
||||
callback(err);
|
||||
});
|
||||
throw err;
|
||||
}
|
||||
};
|
||||
|
||||
module.setRemove = function (key, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.setRemove = async function (key, value) {
|
||||
if (!Array.isArray(value)) {
|
||||
value = [value];
|
||||
}
|
||||
|
||||
value.forEach(function (element, index, array) {
|
||||
array[index] = helpers.valueToString(element);
|
||||
});
|
||||
value = value.map(v => helpers.valueToString(v));
|
||||
|
||||
if (Array.isArray(key)) {
|
||||
db.collection('objects').updateMany({ _key: { $in: key } }, { $pullAll: { members: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
} else {
|
||||
db.collection('objects').updateOne({ _key: key }, { $pullAll: { members: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
}
|
||||
await db.collection('objects').updateMany({ _key: Array.isArray(key) ? { $in: key } : key }, { $pullAll: { members: value } });
|
||||
};
|
||||
|
||||
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;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').updateMany({ _key: { $in: keys } }, { $pull: { members: value } }, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').updateMany({ _key: { $in: keys } }, { $pull: { members: value } });
|
||||
};
|
||||
|
||||
module.isSetMember = function (key, value, callback) {
|
||||
module.isSetMember = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback(null, false);
|
||||
return false;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').findOne({ _key: key, members: value }, { projection: { _id: 0, members: 0 } }, function (err, item) {
|
||||
callback(err, item !== null && item !== undefined);
|
||||
});
|
||||
const item = await db.collection('objects').findOne({ _key: key, members: value }, { projection: { _id: 0, members: 0 } });
|
||||
return item !== null && item !== undefined;
|
||||
};
|
||||
|
||||
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(v => helpers.valueToString(v));
|
||||
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
values[i] = helpers.valueToString(values[i]);
|
||||
}
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, _key: 0 } }, function (err, items) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
const membersSet = new Set(items && Array.isArray(items.members) ? items.members : []);
|
||||
values = values.map(value => membersSet.has(value));
|
||||
callback(null, values);
|
||||
});
|
||||
const result = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, _key: 0 } });
|
||||
const membersSet = new Set(result && Array.isArray(result.members) ? result.members : []);
|
||||
return values.map(v => membersSet.has(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.collection('objects').find({ _key: { $in: sets }, members: value }, { projection: { _id: 0, members: 0 } }).toArray(function (err, result) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
map[item._key] = true;
|
||||
});
|
||||
const result = await db.collection('objects').find({ _key: { $in: sets }, members: value }, { projection: { _id: 0, members: 0 } }).toArray();
|
||||
|
||||
result = sets.map(function (set) {
|
||||
return !!map[set];
|
||||
});
|
||||
|
||||
callback(null, result);
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
map[item._key] = true;
|
||||
});
|
||||
|
||||
return sets.map(set => !!map[set]);
|
||||
};
|
||||
|
||||
module.getSetMembers = function (key, callback) {
|
||||
module.getSetMembers = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, _key: 0 } }, function (err, data) {
|
||||
callback(err, data ? data.members : []);
|
||||
});
|
||||
const data = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0, _key: 0 } });
|
||||
return data ? data.members : [];
|
||||
};
|
||||
|
||||
module.getSetsMembers = function (keys, callback) {
|
||||
module.getSetsMembers = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
db.collection('objects').find({ _key: { $in: keys } }, { projection: { _id: 0 } }).toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
const data = await db.collection('objects').find({ _key: { $in: keys } }, { projection: { _id: 0 } }).toArray();
|
||||
|
||||
var sets = {};
|
||||
data.forEach(function (set) {
|
||||
sets[set._key] = set.members || [];
|
||||
});
|
||||
|
||||
var returnData = new Array(keys.length);
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
returnData[i] = sets[keys[i]] || [];
|
||||
}
|
||||
callback(null, returnData);
|
||||
var sets = {};
|
||||
data.forEach(function (set) {
|
||||
sets[set._key] = set.members || [];
|
||||
});
|
||||
|
||||
return keys.map(k => sets[k] || []);
|
||||
};
|
||||
|
||||
module.setCount = function (key, callback) {
|
||||
module.setCount = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
db.collection('objects').findOne({ _key: key }, { projection: { _id: 0 } }, function (err, data) {
|
||||
callback(err, data ? data.members.length : 0);
|
||||
});
|
||||
const data = await db.collection('objects').findOne({ _key: key }, { projection: { _id: 0 } });
|
||||
return data ? data.members.length : 0;
|
||||
};
|
||||
|
||||
module.setsCount = function (keys, callback) {
|
||||
module.getSetsMembers(keys, function (err, setsMembers) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
var counts = setsMembers.map(function (members) {
|
||||
return (members && members.length) || 0;
|
||||
});
|
||||
callback(null, counts);
|
||||
});
|
||||
module.setsCount = async function (keys) {
|
||||
const setsMembers = await module.getSetsMembers(keys);
|
||||
var counts = setsMembers.map(members => (members && members.length) || 0);
|
||||
return counts;
|
||||
};
|
||||
|
||||
module.setRemoveRandom = function (key, callback) {
|
||||
callback = callback || function () {};
|
||||
db.collection('objects').findOne({ _key: key }, function (err, data) {
|
||||
if (err || !data) {
|
||||
return callback(err);
|
||||
}
|
||||
module.setRemoveRandom = async function (key) {
|
||||
const data = await db.collection('objects').findOne({ _key: key });
|
||||
if (!data) {
|
||||
return;
|
||||
}
|
||||
|
||||
var randomIndex = Math.floor(Math.random() * data.members.length);
|
||||
var value = data.members[randomIndex];
|
||||
module.setRemove(data._key, value, function (err) {
|
||||
callback(err, value);
|
||||
});
|
||||
});
|
||||
var randomIndex = Math.floor(Math.random() * data.members.length);
|
||||
var value = data.members[randomIndex];
|
||||
await module.setRemove(data._key, value);
|
||||
return value;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,44 +1,43 @@
|
||||
'use strict';
|
||||
|
||||
var async = require('async');
|
||||
var utils = require('../../utils');
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
var helpers = require('./helpers');
|
||||
const util = require('util');
|
||||
const sleep = util.promisify(setTimeout);
|
||||
|
||||
require('./sorted/add')(db, module);
|
||||
require('./sorted/remove')(db, module);
|
||||
require('./sorted/union')(db, module);
|
||||
require('./sorted/intersect')(db, module);
|
||||
|
||||
module.getSortedSetRange = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, '-inf', '+inf', 1, false, callback);
|
||||
module.getSortedSetRange = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, '-inf', '+inf', 1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRange = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, '-inf', '+inf', -1, false, callback);
|
||||
module.getSortedSetRevRange = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, '-inf', '+inf', -1, false);
|
||||
};
|
||||
|
||||
module.getSortedSetRangeWithScores = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, '-inf', '+inf', 1, true, callback);
|
||||
module.getSortedSetRangeWithScores = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, '-inf', '+inf', 1, true);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeWithScores = function (key, start, stop, callback) {
|
||||
getSortedSetRange(key, start, stop, '-inf', '+inf', -1, true, callback);
|
||||
module.getSortedSetRevRangeWithScores = async function (key, start, stop) {
|
||||
return await getSortedSetRange(key, start, stop, '-inf', '+inf', -1, true);
|
||||
};
|
||||
|
||||
function getSortedSetRange(key, start, stop, min, max, sort, withScores, callback) {
|
||||
async function getSortedSetRange(key, start, stop, min, max, sort, withScores) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
if (start < 0 && start > stop) {
|
||||
return callback(null, []);
|
||||
const isArray = Array.isArray(key);
|
||||
if ((start < 0 && start > stop) || (isArray && !key.length)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
if (Array.isArray(key)) {
|
||||
if (!key.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
}
|
||||
if (isArray) {
|
||||
if (key.length > 1) {
|
||||
key = { $in: key };
|
||||
} else {
|
||||
@@ -82,53 +81,49 @@ module.exports = function (db, module) {
|
||||
limit = 0;
|
||||
}
|
||||
|
||||
db.collection('objects').find(query, { projection: fields })
|
||||
let data = await db.collection('objects').find(query, { projection: fields })
|
||||
.sort({ score: sort })
|
||||
.skip(start)
|
||||
.limit(limit)
|
||||
.toArray(function (err, data) {
|
||||
if (err || !data) {
|
||||
return callback(err);
|
||||
}
|
||||
.toArray();
|
||||
|
||||
if (reverse) {
|
||||
data.reverse();
|
||||
}
|
||||
if (!withScores) {
|
||||
data = data.map(item => item.value);
|
||||
}
|
||||
if (reverse) {
|
||||
data.reverse();
|
||||
}
|
||||
if (!withScores) {
|
||||
data = data.map(item => item.value);
|
||||
}
|
||||
|
||||
callback(null, data);
|
||||
});
|
||||
return data;
|
||||
}
|
||||
|
||||
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 (parseInt(count, 10) === 0) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
const stop = (parseInt(count, 10) === -1) ? -1 : (start + count - 1);
|
||||
getSortedSetRange(key, start, stop, min, max, sort, withScores, callback);
|
||||
return await getSortedSetRange(key, start, stop, min, max, sort, withScores);
|
||||
}
|
||||
|
||||
module.sortedSetCount = function (key, min, max, callback) {
|
||||
module.sortedSetCount = async function (key, min, max) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
|
||||
var query = { _key: key };
|
||||
@@ -140,334 +135,268 @@ module.exports = function (db, module) {
|
||||
query.score.$lte = max;
|
||||
}
|
||||
|
||||
db.collection('objects').countDocuments(query, function (err, count) {
|
||||
callback(err, count || 0);
|
||||
});
|
||||
const count = await db.collection('objects').countDocuments(query);
|
||||
return count || 0;
|
||||
};
|
||||
|
||||
module.sortedSetCard = function (key, callback) {
|
||||
module.sortedSetCard = async function (key) {
|
||||
if (!key) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
db.collection('objects').countDocuments({ _key: key }, function (err, count) {
|
||||
count = parseInt(count, 10);
|
||||
callback(err, count || 0);
|
||||
});
|
||||
const count = await db.collection('objects').countDocuments({ _key: key });
|
||||
return parseInt(count, 10) || 0;
|
||||
};
|
||||
|
||||
module.sortedSetsCard = function (keys, callback) {
|
||||
module.sortedSetsCard = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
async.map(keys, module.sortedSetCard, callback);
|
||||
const promises = keys.map(k => module.sortedSetCard(k));
|
||||
return await Promise.all(promises);
|
||||
};
|
||||
|
||||
module.sortedSetsCardSum = function (keys, callback) {
|
||||
module.sortedSetsCardSum = async function (keys) {
|
||||
if (!keys || (Array.isArray(keys) && !keys.length)) {
|
||||
return callback(null, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
db.collection('objects').countDocuments({ _key: Array.isArray(keys) ? { $in: keys } : keys }, function (err, count) {
|
||||
count = parseInt(count, 10);
|
||||
callback(err, count || 0);
|
||||
});
|
||||
const count = await db.collection('objects').countDocuments({ _key: Array.isArray(keys) ? { $in: keys } : keys });
|
||||
return parseInt(count, 10) || 0;
|
||||
};
|
||||
|
||||
module.sortedSetRank = function (key, value, callback) {
|
||||
getSortedSetRank(false, key, value, callback);
|
||||
module.sortedSetRank = async function (key, value) {
|
||||
return await getSortedSetRank(false, key, value);
|
||||
};
|
||||
|
||||
module.sortedSetRevRank = function (key, value, callback) {
|
||||
getSortedSetRank(true, key, value, callback);
|
||||
module.sortedSetRevRank = async function (key, value) {
|
||||
return await getSortedSetRank(true, key, value);
|
||||
};
|
||||
|
||||
function getSortedSetRank(reverse, key, value, callback) {
|
||||
async function getSortedSetRank(reverse, key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
module.sortedSetScore(key, value, function (err, score) {
|
||||
if (err || score === null) {
|
||||
return callback(err, null);
|
||||
}
|
||||
const score = await module.sortedSetScore(key, value);
|
||||
if (score === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
db.collection('objects').countDocuments({
|
||||
$or: [
|
||||
{
|
||||
_key: key,
|
||||
score: reverse ? { $gt: score } : { $lt: score },
|
||||
},
|
||||
{
|
||||
_key: key,
|
||||
score: score,
|
||||
value: reverse ? { $gt: value } : { $lt: value },
|
||||
},
|
||||
],
|
||||
}, function (err, rank) { callback(err, rank); });
|
||||
return await db.collection('objects').countDocuments({
|
||||
$or: [
|
||||
{
|
||||
_key: key,
|
||||
score: reverse ? { $gt: score } : { $lt: score },
|
||||
},
|
||||
{
|
||||
_key: key,
|
||||
score: score,
|
||||
value: reverse ? { $gt: value } : { $lt: value },
|
||||
},
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
module.sortedSetsRanks = function (keys, values, callback) {
|
||||
sortedSetsRanks(module.sortedSetRank, keys, values, callback);
|
||||
module.sortedSetsRanks = async function (keys, values) {
|
||||
return await sortedSetsRanks(module.sortedSetRank, keys, values);
|
||||
};
|
||||
|
||||
module.sortedSetsRevRanks = function (keys, values, callback) {
|
||||
sortedSetsRanks(module.sortedSetRevRank, keys, values, callback);
|
||||
module.sortedSetsRevRanks = async function (keys, values) {
|
||||
return await sortedSetsRanks(module.sortedSetRevRank, keys, values);
|
||||
};
|
||||
|
||||
function sortedSetsRanks(method, keys, values, callback) {
|
||||
async function sortedSetsRanks(method, keys, values) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback(null, []);
|
||||
return [];
|
||||
}
|
||||
var data = new Array(values.length);
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
data[i] = { key: keys[i], value: values[i] };
|
||||
}
|
||||
|
||||
async.map(data, function (item, next) {
|
||||
method(item.key, item.value, next);
|
||||
}, callback);
|
||||
const promises = data.map(item => method(item.key, item.value));
|
||||
return await Promise.all(promises);
|
||||
}
|
||||
|
||||
module.sortedSetRanks = function (key, values, callback) {
|
||||
sortedSetRanks(module.getSortedSetRange, key, values, callback);
|
||||
module.sortedSetRanks = async function (key, values) {
|
||||
return await sortedSetRanks(module.getSortedSetRange, key, values);
|
||||
};
|
||||
|
||||
module.sortedSetRevRanks = function (key, values, callback) {
|
||||
sortedSetRanks(module.getSortedSetRevRange, key, values, callback);
|
||||
module.sortedSetRevRanks = async function (key, values) {
|
||||
return await sortedSetRanks(module.getSortedSetRevRange, key, values);
|
||||
};
|
||||
|
||||
function sortedSetRanks(method, key, values, callback) {
|
||||
method(key, 0, -1, function (err, sortedSet) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
async function sortedSetRanks(method, key, values) {
|
||||
const sortedSet = await method(key, 0, -1);
|
||||
|
||||
var result = values.map(function (value) {
|
||||
if (!value) {
|
||||
return null;
|
||||
}
|
||||
|
||||
var result = values.map(function (value) {
|
||||
if (!value) {
|
||||
return null;
|
||||
}
|
||||
var index = sortedSet.indexOf(value.toString());
|
||||
return index !== -1 ? index : null;
|
||||
});
|
||||
|
||||
callback(null, result);
|
||||
var index = sortedSet.indexOf(value.toString());
|
||||
return index !== -1 ? index : null;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
module.sortedSetScore = function (key, value, callback) {
|
||||
module.sortedSetScore = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback(null, null);
|
||||
return null;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
db.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, value: 0 } }, function (err, result) {
|
||||
callback(err, result ? result.score : null);
|
||||
});
|
||||
const result = await db.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, value: 0 } });
|
||||
return result ? result.score : 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);
|
||||
db.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, value: 0 } }).toArray(function (err, result) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
const result = await db.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, value: 0 } }).toArray();
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
if (item) {
|
||||
map[item._key] = item;
|
||||
}
|
||||
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
if (item) {
|
||||
map[item._key] = item;
|
||||
}
|
||||
});
|
||||
|
||||
result = keys.map(function (key) {
|
||||
return map[key] ? map[key].score : null;
|
||||
});
|
||||
|
||||
callback(null, result);
|
||||
});
|
||||
|
||||
return keys.map(key => (map[key] ? map[key].score : 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);
|
||||
db.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0 } }).toArray(function (err, result) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
const result = await db.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0 } }).toArray();
|
||||
|
||||
var valueToScore = {};
|
||||
result.forEach(function (item) {
|
||||
if (item) {
|
||||
valueToScore[item.value] = item.score;
|
||||
}
|
||||
|
||||
var map = {};
|
||||
result.forEach(function (item) {
|
||||
map[item.value] = item.score;
|
||||
});
|
||||
|
||||
var returnData = new Array(values.length);
|
||||
var score;
|
||||
|
||||
for (var i = 0; i < values.length; i += 1) {
|
||||
score = map[values[i]];
|
||||
returnData[i] = utils.isNumber(score) ? score : null;
|
||||
}
|
||||
|
||||
callback(null, returnData);
|
||||
});
|
||||
|
||||
return values.map(v => (utils.isNumber(valueToScore[v]) ? valueToScore[v] : null));
|
||||
};
|
||||
|
||||
module.isSortedSetMember = function (key, value, callback) {
|
||||
module.isSortedSetMember = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
db.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, score: 0 } }, function (err, result) {
|
||||
callback(err, !!result);
|
||||
});
|
||||
const result = await db.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, score: 0 } });
|
||||
return !!result;
|
||||
};
|
||||
|
||||
module.isSortedSetMembers = function (key, values, callback) {
|
||||
module.isSortedSetMembers = async function (key, values) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
values = values.map(helpers.valueToString);
|
||||
db.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0, score: 0 } }).toArray(function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
var isMember = {};
|
||||
results.forEach(function (item) {
|
||||
if (item) {
|
||||
isMember[item.value] = true;
|
||||
}
|
||||
});
|
||||
const results = await db.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0, score: 0 } }).toArray();
|
||||
|
||||
values = values.map(function (value) {
|
||||
return !!isMember[value];
|
||||
});
|
||||
callback(null, values);
|
||||
var isMember = {};
|
||||
results.forEach(function (item) {
|
||||
if (item) {
|
||||
isMember[item.value] = true;
|
||||
}
|
||||
});
|
||||
|
||||
return values.map(value => !!isMember[value]);
|
||||
};
|
||||
|
||||
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);
|
||||
db.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, score: 0 } }).toArray(function (err, results) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
var isMember = {};
|
||||
results.forEach(function (item) {
|
||||
if (item) {
|
||||
isMember[item._key] = true;
|
||||
}
|
||||
});
|
||||
const results = await db.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, score: 0 } }).toArray();
|
||||
|
||||
results = keys.map(function (key) {
|
||||
return !!isMember[key];
|
||||
});
|
||||
callback(null, results);
|
||||
var isMember = {};
|
||||
results.forEach(function (item) {
|
||||
if (item) {
|
||||
isMember[item._key] = true;
|
||||
}
|
||||
});
|
||||
|
||||
return keys.map(key => !!isMember[key]);
|
||||
};
|
||||
|
||||
module.getSortedSetsMembers = function (keys, callback) {
|
||||
module.getSortedSetsMembers = async function (keys) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return setImmediate(callback, null, []);
|
||||
return [];
|
||||
}
|
||||
db.collection('objects').find({ _key: { $in: keys } }, { projection: { _id: 0, score: 0 } }).sort({ score: 1 }).toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
const data = await db.collection('objects').find({ _key: { $in: keys } }, { projection: { _id: 0, score: 0 } }).sort({ score: 1 }).toArray();
|
||||
|
||||
var sets = {};
|
||||
data.forEach(function (set) {
|
||||
sets[set._key] = sets[set._key] || [];
|
||||
sets[set._key].push(set.value);
|
||||
});
|
||||
|
||||
var returnData = new Array(keys.length);
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
returnData[i] = sets[keys[i]] || [];
|
||||
}
|
||||
callback(null, returnData);
|
||||
var sets = {};
|
||||
data.forEach(function (set) {
|
||||
sets[set._key] = sets[set._key] || [];
|
||||
sets[set._key].push(set.value);
|
||||
});
|
||||
|
||||
return keys.map(k => sets[k] || []);
|
||||
};
|
||||
|
||||
module.sortedSetIncrBy = function (key, increment, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.sortedSetIncrBy = async function (key, increment, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
var data = {};
|
||||
value = helpers.valueToString(value);
|
||||
data.score = parseFloat(increment);
|
||||
|
||||
db.collection('objects').findOneAndUpdate({ _key: key, value: value }, { $inc: data }, { returnOriginal: false, upsert: true }, function (err, result) {
|
||||
try {
|
||||
const result = await db.collection('objects').findOneAndUpdate({ _key: key, value: value }, { $inc: data }, { returnOriginal: false, upsert: true });
|
||||
return result && result.value ? result.value.score : null;
|
||||
} catch (err) {
|
||||
// if there is duplicate key error retry the upsert
|
||||
// https://github.com/NodeBB/NodeBB/issues/4467
|
||||
// https://jira.mongodb.org/browse/SERVER-14322
|
||||
// https://docs.mongodb.org/manual/reference/command/findAndModify/#upsert-and-unique-index
|
||||
if (err && err.message.startsWith('E11000 duplicate key error')) {
|
||||
return process.nextTick(module.sortedSetIncrBy, key, increment, value, callback);
|
||||
return await module.sortedSetIncrBy(key, increment, value);
|
||||
}
|
||||
callback(err, result && result.value ? result.value.score : null);
|
||||
});
|
||||
};
|
||||
|
||||
module.getSortedSetRangeByLex = function (key, min, max, start, count, callback) {
|
||||
sortedSetLex(key, min, max, 1, start, count, callback);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByLex = function (key, max, min, start, count, callback) {
|
||||
sortedSetLex(key, min, max, -1, start, count, callback);
|
||||
};
|
||||
|
||||
module.sortedSetLexCount = function (key, min, max, callback) {
|
||||
sortedSetLex(key, min, max, 1, 0, 0, function (err, data) {
|
||||
callback(err, data ? data.length : null);
|
||||
});
|
||||
};
|
||||
|
||||
function sortedSetLex(key, min, max, sort, start, count, callback) {
|
||||
if (!callback) {
|
||||
callback = start;
|
||||
start = 0;
|
||||
count = 0;
|
||||
throw err;
|
||||
}
|
||||
};
|
||||
|
||||
module.getSortedSetRangeByLex = async function (key, min, max, start, count) {
|
||||
return await sortedSetLex(key, min, max, 1, start, count);
|
||||
};
|
||||
|
||||
module.getSortedSetRevRangeByLex = async function (key, max, min, start, count) {
|
||||
return await sortedSetLex(key, min, max, -1, start, count);
|
||||
};
|
||||
|
||||
module.sortedSetLexCount = async function (key, min, max) {
|
||||
const data = await sortedSetLex(key, min, max, 1, 0, 0);
|
||||
return data ? data.length : null;
|
||||
};
|
||||
|
||||
async function sortedSetLex(key, min, max, sort, start, count) {
|
||||
var query = { _key: key };
|
||||
start = start !== undefined ? start : 0;
|
||||
count = count !== undefined ? count : 0;
|
||||
buildLexQuery(query, min, max);
|
||||
|
||||
db.collection('objects').find(query, { projection: { _id: 0, _key: 0, score: 0 } })
|
||||
const data = await db.collection('objects').find(query, { projection: { _id: 0, _key: 0, score: 0 } })
|
||||
.sort({ value: sort })
|
||||
.skip(start)
|
||||
.limit(count === -1 ? 0 : count)
|
||||
.toArray(function (err, data) {
|
||||
if (err) {
|
||||
return callback(err);
|
||||
}
|
||||
data = data.map(function (item) {
|
||||
return item && item.value;
|
||||
});
|
||||
callback(err, data);
|
||||
});
|
||||
.toArray();
|
||||
|
||||
return data.map(item => item && item.value);
|
||||
}
|
||||
|
||||
module.sortedSetRemoveRangeByLex = function (key, min, max, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
|
||||
module.sortedSetRemoveRangeByLex = async function (key, min, max) {
|
||||
var query = { _key: key };
|
||||
buildLexQuery(query, min, max);
|
||||
|
||||
db.collection('objects').deleteMany(query, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').deleteMany(query);
|
||||
};
|
||||
|
||||
function buildLexQuery(query, min, max) {
|
||||
@@ -492,51 +421,39 @@ module.exports = function (db, module) {
|
||||
}
|
||||
}
|
||||
|
||||
module.processSortedSet = function (setKey, processFn, options, callback) {
|
||||
module.processSortedSet = async function (setKey, processFn, options) {
|
||||
var done = false;
|
||||
var ids = [];
|
||||
var project = { _id: 0, _key: 0 };
|
||||
|
||||
if (!options.withScores) {
|
||||
project.score = 0;
|
||||
}
|
||||
var cursor = db.collection('objects').find({ _key: setKey }, { projection: project })
|
||||
var cursor = await db.collection('objects').find({ _key: setKey }, { projection: project })
|
||||
.sort({ score: 1 })
|
||||
.batchSize(options.batch);
|
||||
|
||||
async.whilst(
|
||||
function (next) {
|
||||
next(null, !done);
|
||||
},
|
||||
function (next) {
|
||||
async.waterfall([
|
||||
function (next) {
|
||||
cursor.next(next);
|
||||
},
|
||||
function (item, _next) {
|
||||
if (item === null) {
|
||||
done = true;
|
||||
} else {
|
||||
ids.push(options.withScores ? item : item.value);
|
||||
}
|
||||
if (processFn && processFn.constructor && processFn.constructor.name !== 'AsyncFunction') {
|
||||
processFn = util.promisify(processFn);
|
||||
}
|
||||
|
||||
if (ids.length < options.batch && (!done || ids.length === 0)) {
|
||||
return process.nextTick(next, null);
|
||||
}
|
||||
processFn(ids, function (err) {
|
||||
_next(err);
|
||||
});
|
||||
},
|
||||
function (next) {
|
||||
ids = [];
|
||||
if (options.interval) {
|
||||
setTimeout(next, options.interval);
|
||||
} else {
|
||||
process.nextTick(next);
|
||||
}
|
||||
},
|
||||
], next);
|
||||
},
|
||||
callback
|
||||
);
|
||||
while (!done) {
|
||||
/* eslint-disable no-await-in-loop */
|
||||
const item = await cursor.next();
|
||||
if (item === null) {
|
||||
done = true;
|
||||
} else {
|
||||
ids.push(options.withScores ? item : item.value);
|
||||
}
|
||||
|
||||
if (ids.length >= options.batch || (done && ids.length !== 0)) {
|
||||
await processFn(ids);
|
||||
|
||||
ids.length = 0;
|
||||
if (options.interval) {
|
||||
await sleep(options.interval);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,88 +1,82 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
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);
|
||||
|
||||
db.collection('objects').updateOne({ _key: key, value: value }, { $set: { score: parseFloat(score) } }, { upsert: true, w: 1 }, function (err) {
|
||||
try {
|
||||
await db.collection('objects').updateOne({ _key: key, value: value }, { $set: { score: parseFloat(score) } }, { upsert: true, w: 1 });
|
||||
} catch (err) {
|
||||
if (err && err.message.startsWith('E11000 duplicate key error')) {
|
||||
return process.nextTick(module.sortedSetAdd, key, score, value, callback);
|
||||
return await module.sortedSetAdd(key, score, value);
|
||||
}
|
||||
callback(err);
|
||||
});
|
||||
throw err;
|
||||
}
|
||||
};
|
||||
|
||||
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);
|
||||
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
|
||||
for (var i = 0; i < scores.length; i += 1) {
|
||||
bulk.find({ _key: key, value: values[i] }).upsert().updateOne({ $set: { score: parseFloat(scores[i]) } });
|
||||
}
|
||||
|
||||
bulk.execute(function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await bulk.execute();
|
||||
}
|
||||
|
||||
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 setImmediate(callback);
|
||||
return;
|
||||
}
|
||||
const isArrayOfScores = Array.isArray(scores);
|
||||
if (!isArrayOfScores && !utils.isNumber(scores)) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-score, ' + scores + ']]'));
|
||||
throw new Error('[[error:invalid-score, ' + scores + ']]');
|
||||
}
|
||||
|
||||
if (isArrayOfScores && scores.length !== keys.length) {
|
||||
return setImmediate(callback, new Error('[[error:invalid-data]]'));
|
||||
throw new Error('[[error:invalid-data]]');
|
||||
}
|
||||
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
|
||||
for (var i = 0; i < keys.length; i += 1) {
|
||||
bulk.find({ _key: keys[i], value: value }).upsert().updateOne({ $set: { score: parseFloat(isArrayOfScores ? scores[i] : scores) } });
|
||||
}
|
||||
|
||||
bulk.execute(err => callback(err));
|
||||
await bulk.execute();
|
||||
};
|
||||
|
||||
module.sortedSetAddBulk = function (data, callback) {
|
||||
module.sortedSetAddBulk = async function (data) {
|
||||
if (!Array.isArray(data) || !data.length) {
|
||||
return setImmediate(callback);
|
||||
return;
|
||||
}
|
||||
var bulk = db.collection('objects').initializeUnorderedBulkOp();
|
||||
data.forEach(function (item) {
|
||||
bulk.find({ _key: item[0], value: String(item[2]) }).upsert().updateOne({ $set: { score: parseFloat(item[1]) } });
|
||||
});
|
||||
bulk.execute(err => callback(err));
|
||||
await bulk.execute();
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
'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;
|
||||
}
|
||||
|
||||
var pipeline = [
|
||||
@@ -13,23 +13,22 @@ module.exports = function (db, module) {
|
||||
{ $group: { _id: null, count: { $sum: 1 } } },
|
||||
];
|
||||
|
||||
db.collection('objects').aggregate(pipeline).toArray(function (err, data) {
|
||||
callback(err, Array.isArray(data) && data.length ? data[0].count : 0);
|
||||
});
|
||||
const data = await db.collection('objects').aggregate(pipeline).toArray();
|
||||
return Array.isArray(data) && data.length ? data[0].count : 0;
|
||||
};
|
||||
|
||||
|
||||
module.getSortedSetIntersect = function (params, callback) {
|
||||
module.getSortedSetIntersect = async function (params) {
|
||||
params.sort = 1;
|
||||
getSortedSetRevIntersect(params, callback);
|
||||
return await getSortedSetRevIntersect(params);
|
||||
};
|
||||
|
||||
module.getSortedSetRevIntersect = function (params, callback) {
|
||||
module.getSortedSetRevIntersect = async function (params) {
|
||||
params.sort = -1;
|
||||
getSortedSetRevIntersect(params, callback);
|
||||
return await getSortedSetRevIntersect(params);
|
||||
};
|
||||
|
||||
function getSortedSetRevIntersect(params, callback) {
|
||||
async function getSortedSetRevIntersect(params) {
|
||||
var sets = params.sets;
|
||||
var start = params.hasOwnProperty('start') ? params.start : 0;
|
||||
var stop = params.hasOwnProperty('stop') ? params.stop : -1;
|
||||
@@ -88,18 +87,11 @@ module.exports = function (db, module) {
|
||||
}
|
||||
pipeline.push({ $project: project });
|
||||
|
||||
db.collection('objects').aggregate(pipeline).toArray(function (err, data) {
|
||||
if (err || !data) {
|
||||
return callback(err);
|
||||
}
|
||||
let data = await db.collection('objects').aggregate(pipeline).toArray();
|
||||
|
||||
if (!params.withScores) {
|
||||
data = data.map(function (item) {
|
||||
return item.value;
|
||||
});
|
||||
}
|
||||
|
||||
callback(null, data);
|
||||
});
|
||||
if (!params.withScores) {
|
||||
data = data.map(item => item.value);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1,45 +1,41 @@
|
||||
'use strict';
|
||||
|
||||
module.exports = function (db, module) {
|
||||
var helpers = module.helpers.mongo;
|
||||
var helpers = require('../helpers');
|
||||
|
||||
module.sortedSetRemove = function (key, value, callback) {
|
||||
function done(err) {
|
||||
callback(err);
|
||||
}
|
||||
callback = callback || helpers.noop;
|
||||
module.sortedSetRemove = async function (key, value) {
|
||||
if (!key) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
const isValueArray = Array.isArray(value);
|
||||
if (!value || (isValueArray && !value.length)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Array.isArray(value)) {
|
||||
if (isValueArray) {
|
||||
value = value.map(helpers.valueToString);
|
||||
} else {
|
||||
value = helpers.valueToString(value);
|
||||
}
|
||||
|
||||
db.collection('objects').deleteMany({
|
||||
await db.collection('objects').deleteMany({
|
||||
_key: Array.isArray(key) ? { $in: key } : key,
|
||||
value: Array.isArray(value) ? { $in: value } : value,
|
||||
}, done);
|
||||
};
|
||||
|
||||
module.sortedSetsRemove = function (keys, value, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
db.collection('objects').deleteMany({ _key: { $in: keys }, value: value }, function (err) {
|
||||
callback(err);
|
||||
value: isValueArray ? { $in: value } : value,
|
||||
});
|
||||
};
|
||||
|
||||
module.sortedSetsRemoveRangeByScore = function (keys, min, max, callback) {
|
||||
callback = callback || helpers.noop;
|
||||
module.sortedSetsRemove = async function (keys, value) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
value = helpers.valueToString(value);
|
||||
|
||||
await db.collection('objects').deleteMany({ _key: { $in: keys }, value: value });
|
||||
};
|
||||
|
||||
module.sortedSetsRemoveRangeByScore = async function (keys, min, max) {
|
||||
if (!Array.isArray(keys) || !keys.length) {
|
||||
return;
|
||||
}
|
||||
var query = { _key: { $in: keys } };
|
||||
|
||||
@@ -51,8 +47,6 @@ module.exports = function (db, module) {
|
||||
query.score.$lte = parseFloat(max);
|
||||
}
|
||||
|
||||
db.collection('objects').deleteMany(query, function (err) {
|
||||
callback(err);
|
||||
});
|
||||
await db.collection('objects').deleteMany(query);
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,34 +1,33 @@
|
||||
'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.collection('objects').aggregate([
|
||||
const data = await db.collection('objects').aggregate([
|
||||
{ $match: { _key: { $in: keys } } },
|
||||
{ $group: { _id: { value: '$value' } } },
|
||||
{ $group: { _id: null, count: { $sum: 1 } } },
|
||||
{ $project: { _id: 0, count: '$count' } },
|
||||
]).toArray(function (err, data) {
|
||||
callback(err, Array.isArray(data) && data.length ? data[0].count : 0);
|
||||
});
|
||||
]).toArray();
|
||||
return Array.isArray(data) && data.length ? data[0].count : 0;
|
||||
};
|
||||
|
||||
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) {
|
||||
if (!Array.isArray(params.sets) || !params.sets.length) {
|
||||
return callback();
|
||||
return;
|
||||
}
|
||||
var limit = params.stop - params.start + 1;
|
||||
if (limit <= 0) {
|
||||
@@ -62,18 +61,10 @@ module.exports = function (db, module) {
|
||||
}
|
||||
pipeline.push({ $project: project });
|
||||
|
||||
db.collection('objects').aggregate(pipeline).toArray(function (err, data) {
|
||||
if (err || !data) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (!params.withScores) {
|
||||
data = data.map(function (item) {
|
||||
return item.value;
|
||||
});
|
||||
}
|
||||
|
||||
callback(null, data);
|
||||
});
|
||||
let data = await db.collection('objects').aggregate(pipeline).toArray();
|
||||
if (!params.withScores) {
|
||||
data = data.map(item => item.value);
|
||||
}
|
||||
return data;
|
||||
}
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user