6222586690

Committed 18 Sep 2023 12:36PM UTC coverage: 84.965% (-0.01%) from 84.976%

Build # 6222586690

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #14 from CMU-17313Q/issue2-dropdown-to-add-type-attribute-to-post-object

Attempt 2 to add attribute "tag" to the post object, and create a dropdown in the front end to choose the type

Run Details

10208 of 13255 branches covered (0.0%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 2 files covered. (100.0%)

5 existing lines in 2 files now uncovered.

22598 of 25356 relevant lines covered (89.12%)

3131.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.7

/src/database/mongo/sorted.js

'use strict';

const _ = require('lodash');
const utils = require('../../utils');

module.exports = function (module) {
    const helpers = require('./helpers');
    const dbHelpers = require('../helpers');

    const util = require('util');
    const sleep = util.promisify(setTimeout);

    require('./sorted/add')(module);
    require('./sorted/remove')(module);
    require('./sorted/union')(module);
    require('./sorted/intersect')(module);

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

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

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

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

    async function getSortedSetRange(key, start, stop, min, max, sort, withScores) {
        if (!key) {
            return;
        }
        const isArray = Array.isArray(key);
        if ((start < 0 && start > stop) || (isArray && !key.length)) {
            return [];
        }
        const query = { _key: key };
        if (isArray) {
            if (key.length > 1) {
                query._key = { $in: key };
            } else {
                query._key = key[0];
            }
        }

        if (min !== '-inf') {
            query.score = { $gte: min };
        }
        if (max !== '+inf') {
            query.score = query.score || {};
            query.score.$lte = max;
        }

        if (max === min) {
            query.score = max;
        }

        const fields = { _id: 0, _key: 0 };
        if (!withScores) {
            fields.score = 0;
        }

        let reverse = false;
        if (start === 0 && stop < -1) {
            reverse = true;
            sort *= -1;
            start = Math.abs(stop + 1);
            stop = -1;
        } else if (start < 0 && stop > start) {
            const tmp1 = Math.abs(stop + 1);
            stop = Math.abs(start + 1);
            start = tmp1;
        }

        let limit = stop - start + 1;
        if (limit <= 0) {
            limit = 0;
        }

        let result = [];
        async function doQuery(_key, fields, skip, limit) {
            return await module.client.collection('objects').find({ ...query, ...{ _key: _key } }, { projection: fields })
                .sort({ score: sort })
                .skip(skip)
                .limit(limit)
                .toArray();
        }

        if (isArray && key.length > 100) {
            const batches = [];
            const batch = require('../../batch');
            const batchSize = Math.ceil(key.length / Math.ceil(key.length / 100));
            await batch.processArray(key, async currentBatch => batches.push(currentBatch), { batch: batchSize });
            const batchData = await Promise.all(batches.map(
                batch => doQuery({ $in: batch }, { _id: 0, _key: 0 }, 0, stop + 1)
            ));
            result = dbHelpers.mergeBatch(batchData, 0, stop, sort);
            if (start > 0) {
                result = result.slice(start, stop !== -1 ? stop + 1 : undefined);
            }
        } else {
            result = await doQuery(query._key, fields, start, limit);
        }

        if (reverse) {
            result.reverse();
        }
        if (!withScores) {
            result = result.map(item => item.value);
        }

        return result;
    }

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

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

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

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

    async function getSortedSetRangeByScore(key, start, count, min, max, sort, withScores) {
        if (parseInt(count, 10) === 0) {
            return [];
        }
        const stop = (parseInt(count, 10) === -1) ? -1 : (start + count - 1);
        return await getSortedSetRange(key, start, stop, min, max, sort, withScores);
    }

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

        const query = { _key: key };
        if (min !== '-inf') {
            query.score = { $gte: min };
        }
        if (max !== '+inf') {
            query.score = query.score || {};
            query.score.$lte = max;
        }

        const count = await module.client.collection('objects').countDocuments(query);
        return count || 0;
    };

    module.sortedSetCard = async function (key) {
        if (!key) {
            return 0;
        }
        const count = await module.client.collection('objects').countDocuments({ _key: key });
        return parseInt(count, 10) || 0;
    };

    module.sortedSetsCard = async function (keys) {
        if (!Array.isArray(keys) || !keys.length) {
            return [];
        }
        const promises = keys.map(k => module.sortedSetCard(k));
        return await Promise.all(promises);
    };

    module.sortedSetsCardSum = async function (keys) {
        if (!keys || (Array.isArray(keys) && !keys.length)) {
            return 0;
        }

        const count = await module.client.collection('objects').countDocuments({ _key: Array.isArray(keys) ? { $in: keys } : keys });
        return parseInt(count, 10) || 0;
    };

    module.sortedSetRank = async function (key, value) {
        return await getSortedSetRank(false, key, value);
    };

    module.sortedSetRevRank = async function (key, value) {
        return await getSortedSetRank(true, key, value);
    };

    async function getSortedSetRank(reverse, key, value) {
        if (!key) {
            return;
        }
        value = helpers.valueToString(value);
        const score = await module.sortedSetScore(key, value);
        if (score === null) {
            return null;
        }

        return await module.client.collection('objects').countDocuments({
            $or: [
                {
                    _key: key,
                    score: reverse ? { $gt: score } : { $lt: score },
                },
                {
                    _key: key,
                    score: score,
                    value: reverse ? { $gt: value } : { $lt: value },
                },
            ],
        });
    }

    module.sortedSetsRanks = async function (keys, values) {
        return await sortedSetsRanks(module.sortedSetRank, keys, values);
    };

    module.sortedSetsRevRanks = async function (keys, values) {
        return await sortedSetsRanks(module.sortedSetRevRank, keys, values);
    };

    async function sortedSetsRanks(method, keys, values) {
        if (!Array.isArray(keys) || !keys.length) {
            return [];
        }
        const data = new Array(values.length);
        for (let i = 0; i < values.length; i += 1) {
            data[i] = { key: keys[i], value: values[i] };
        }
        const promises = data.map(item => method(item.key, item.value));
        return await Promise.all(promises);
    }

    module.sortedSetRanks = async function (key, values) {
        return await sortedSetRanks(false, key, values);
    };

    module.sortedSetRevRanks = async function (key, values) {
        return await sortedSetRanks(true, key, values);
    };

    async function sortedSetRanks(reverse, key, values) {
        if (values.length === 1) {
            return [await getSortedSetRank(reverse, key, values[0])];
        }
        const sortedSet = await module[reverse ? 'getSortedSetRevRange' : 'getSortedSetRange'](key, 0, -1);
        return values.map((value) => {
            if (!value) {
                return null;
            }
            const index = sortedSet.indexOf(value.toString());
            return index !== -1 ? index : null;
        });
    }

    module.sortedSetScore = async function (key, value) {
        if (!key) {
            return null;
        }
        value = helpers.valueToString(value);
        const result = await module.client.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, value: 0 } });
        return result ? result.score : null;
    };

    module.sortedSetsScore = async function (keys, value) {
        if (!Array.isArray(keys) || !keys.length) {
            return [];
        }
        value = helpers.valueToString(value);
        const result = await module.client.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, value: 0 } }).toArray();
        const map = {};
        result.forEach((item) => {
            if (item) {
                map[item._key] = item;
            }
        });

        return keys.map(key => (map[key] ? map[key].score : null));
    };

    module.sortedSetScores = async function (key, values) {
        if (!key) {
            return null;
        }
        if (!values.length) {
            return [];
        }
        values = values.map(helpers.valueToString);
        const result = await module.client.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0 } }).toArray();

        const valueToScore = {};
        result.forEach((item) => {
            if (item) {
                valueToScore[item.value] = item.score;
            }
        });

        return values.map(v => (utils.isNumber(valueToScore[v]) ? valueToScore[v] : null));
    };

    module.isSortedSetMember = async function (key, value) {
        if (!key) {
            return;
        }
        value = helpers.valueToString(value);
        const result = await module.client.collection('objects').findOne({
            _key: key, value: value,
        }, {
            projection: { _id: 0, value: 1 },
        });
        return !!result;
    };

    module.isSortedSetMembers = async function (key, values) {
        if (!key) {
            return;
        }
        if (!values.length) {
            return [];
        }
        values = values.map(helpers.valueToString);
        const results = await module.client.collection('objects').find({
            _key: key, value: { $in: values },
        }, {
            projection: { _id: 0, value: 1 },
        }).toArray();

        const isMember = {};
        results.forEach((item) => {
            if (item) {
                isMember[item.value] = true;
            }
        });

        return values.map(value => !!isMember[value]);
    };

    module.isMemberOfSortedSets = async function (keys, value) {
        if (!Array.isArray(keys) || !keys.length) {
            return [];
        }
        value = helpers.valueToString(value);
        const results = await module.client.collection('objects').find({
            _key: { $in: keys }, value: value,
        }, {
            projection: { _id: 0, _key: 1, value: 1 },
        }).toArray();

        const isMember = {};
        results.forEach((item) => {
            if (item) {
                isMember[item._key] = true;
            }
        });

        return keys.map(key => !!isMember[key]);
    };

    module.getSortedSetMembers = async function (key) {
        const data = await module.getSortedSetsMembers([key]);
        return data && data[0];
    };

    module.getSortedSetsMembers = async function (keys) {
        if (!Array.isArray(keys) || !keys.length) {
            return [];
        }
        const arrayOfKeys = keys.length > 1;
        const projection = { _id: 0, value: 1 };
        if (arrayOfKeys) {
            projection._key = 1;
        }
        const data = await module.client.collection('objects').find({
            _key: arrayOfKeys ? { $in: keys } : keys[0],
        }, { projection: projection }).toArray();

        if (!arrayOfKeys) {
            return [data.map(item => item.value)];
        }
        const sets = {};
        data.forEach((item) => {
            sets[item._key] = sets[item._key] || [];
            sets[item._key].push(item.value);
        });

        return keys.map(k => sets[k] || []);
    };

    module.sortedSetIncrBy = async function (key, increment, value) {
        if (!key) {
            return;
        }
        const data = {};
        value = helpers.valueToString(value);
        data.score = parseFloat(increment);

        try {
            const result = await module.client.collection('objects').findOneAndUpdate({
                _key: key,
                value: value,
            }, {
                $inc: data,
            }, {
                returnDocument: 'after',
                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 await module.sortedSetIncrBy(key, increment, value);
            }
            throw err;
        }
    };

    module.sortedSetIncrByBulk = async function (data) {
        const bulk = module.client.collection('objects').initializeUnorderedBulkOp();
        data.forEach((item) => {
            bulk.find({ _key: item[0], value: helpers.valueToString(item[2]) })
                .upsert()
                .update({ $inc: { score: parseFloat(item[1]) } });
        });
        await bulk.execute();
        const result = await module.client.collection('objects').find({
            _key: { $in: _.uniq(data.map(i => i[0])) },
            value: { $in: _.uniq(data.map(i => i[2])) },
        }, {
            projection: { _id: 0, _key: 1, value: 1, score: 1 },
        }).toArray();

        const map = {};
        result.forEach((item) => {
            map[`${item._key}:${item.value}`] = item.score;
        });
        return data.map(item => map[`${item[0]}:${item[2]}`]);
    };

    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) {
        const query = { _key: key };
        start = start !== undefined ? start : 0;
        count = count !== undefined ? count : 0;
        buildLexQuery(query, min, max);

        const data = await module.client.collection('objects').find(query, { projection: { _id: 0, value: 1 } })
            .sort({ value: sort })
            .skip(start)
            .limit(count === -1 ? 0 : count)
            .toArray();

        return data.map(item => item && item.value);
    }

    module.sortedSetRemoveRangeByLex = async function (key, min, max) {
        const query = { _key: key };
        buildLexQuery(query, min, max);

        await module.client.collection('objects').deleteMany(query);
    };

    function buildLexQuery(query, min, max) {
        if (min !== '-') {
            if (min.match(/^\(/)) {
                query.value = { $gt: min.slice(1) };
            } else if (min.match(/^\[/)) {
                query.value = { $gte: min.slice(1) };
            } else {
                query.value = { $gte: min };
            }
        }
        if (max !== '+') {
            query.value = query.value || {};
            if (max.match(/^\(/)) {
                query.value.$lt = max.slice(1);
            } else if (max.match(/^\[/)) {
                query.value.$lte = max.slice(1);
            } else {
                query.value.$lte = max;
            }
        }
    }

    module.getSortedSetScan = async function (params) {
        const project = { _id: 0, value: 1 };
        if (params.withScores) {
            project.score = 1;
        }

        const match = helpers.buildMatchQuery(params.match);
        let regex;
        try {
            regex = new RegExp(match);
        } catch (err) {
            return [];
        }

        const cursor = module.client.collection('objects').find({
            _key: params.key, value: { $regex: regex },
        }, { projection: project });

        if (params.limit) {
            cursor.limit(params.limit);
        }

        const data = await cursor.toArray();
        if (!params.withScores) {
            return data.map(d => d.value);
        }
        return data;
    };

    module.processSortedSet = async function (setKey, processFn, options) {
        let done = false;
        const ids = [];
        const project = { _id: 0, _key: 0 };

        if (!options.withScores) {
            project.score = 0;
        }
        const cursor = await module.client.collection('objects').find({ _key: setKey }, { projection: project })
            .sort({ score: 1 })
            .batchSize(options.batch);

        if (processFn && processFn.constructor && processFn.constructor.name !== 'AsyncFunction') {
            processFn = util.promisify(processFn);
        }

        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	'use strict';
2
3	const _ = require('lodash');	10✔
4	const utils = require('../../utils');	10✔
5
6	module.exports = function (module) {	10✔
7	const helpers = require('./helpers');	10✔
8	const dbHelpers = require('../helpers');	10✔
9
10	const util = require('util');	10✔
11	const sleep = util.promisify(setTimeout);	10✔
12
13	require('./sorted/add')(module);	10✔
14	require('./sorted/remove')(module);	10✔
15	require('./sorted/union')(module);	10✔
16	require('./sorted/intersect')(module);	10✔
17
18	module.getSortedSetRange = async function (key, start, stop) {	10✔
19	return await getSortedSetRange(key, start, stop, '-inf', '+inf', 1, false);	1,606✔
20	};
21
22	module.getSortedSetRevRange = async function (key, start, stop) {	10✔
23	return await getSortedSetRange(key, start, stop, '-inf', '+inf', -1, false);	11,724✔
24	};
25
26	module.getSortedSetRangeWithScores = async function (key, start, stop) {	10✔
27	return await getSortedSetRange(key, start, stop, '-inf', '+inf', 1, true);	1,247✔
28	};
29
30	module.getSortedSetRevRangeWithScores = async function (key, start, stop) {	10✔
31	return await getSortedSetRange(key, start, stop, '-inf', '+inf', -1, true);	508✔
32	};
33
34	async function getSortedSetRange(key, start, stop, min, max, sort, withScores) {
35	if (!key) {	15,451!
36	return;	×
37	}
38	const isArray = Array.isArray(key);	15,451✔
39	if ((start < 0 && start > stop) \|\| (isArray && !key.length)) {	15,451✔
40	return [];	12✔
41	}
42	const query = { _key: key };	15,439✔
43	if (isArray) {	15,439✔
44	if (key.length > 1) {	318✔
45	query._key = { $in: key };	208✔
46	} else {
47	query._key = key[0];	110✔
48	}
49	}
50
51	if (min !== '-inf') {	15,439✔
52	query.score = { $gte: min };	340✔
53	}
54	if (max !== '+inf') {	15,439✔
55	query.score = query.score \|\| {};	78✔
56	query.score.$lte = max;	78✔
57	}
58
59	if (max === min) {	15,439✔
60	query.score = max;	50✔
61	}
62
63	const fields = { _id: 0, _key: 0 };	15,439✔
64	if (!withScores) {	15,439✔
65	fields.score = 0;	13,512✔
66	}
67
68	let reverse = false;	15,439✔
69	if (start === 0 && stop < -1) {	15,439✔
70	reverse = true;	2✔
71	sort *= -1;	2✔
72	start = Math.abs(stop + 1);	2✔
73	stop = -1;	2✔
74	} else if (start < 0 && stop > start) {	15,437✔
75	const tmp1 = Math.abs(stop + 1);	6✔
76	stop = Math.abs(start + 1);	6✔
77	start = tmp1;	6✔
78	}
79
80	let limit = stop - start + 1;	15,439✔
81	if (limit <= 0) {	15,439✔
82	limit = 0;	11,410✔
83	}
84
85	let result = [];	15,439✔
86	async function doQuery(_key, fields, skip, limit) {
87	return await module.client.collection('objects').find({ ...query, ...{ _key: _key } }, { projection: fields })	15,463✔
88	.sort({ score: sort })
89	.skip(skip)
90	.limit(limit)
91	.toArray();
92	}
93
94	if (isArray && key.length > 100) {	15,439✔
95	const batches = [];	8✔
96	const batch = require('../../batch');	8✔
97	const batchSize = Math.ceil(key.length / Math.ceil(key.length / 100));	8✔
98	await batch.processArray(key, async currentBatch => batches.push(currentBatch), { batch: batchSize });	32✔
99	const batchData = await Promise.all(batches.map(	8✔
100	batch => doQuery({ $in: batch }, { _id: 0, _key: 0 }, 0, stop + 1)	32✔
101	));
102	result = dbHelpers.mergeBatch(batchData, 0, stop, sort);	8✔
103	if (start > 0) {	8✔
104	result = result.slice(start, stop !== -1 ? stop + 1 : undefined);	2!
105	}
106	} else {
107	result = await doQuery(query._key, fields, start, limit);	15,431✔
108	}
109
110	if (reverse) {	15,439✔
111	result.reverse();	2✔
112	}
113	if (!withScores) {	15,439✔
114	result = result.map(item => item.value);	97,095✔
115	}
116
117	return result;	15,439✔
118	}
119
120	module.getSortedSetRangeByScore = async function (key, start, count, min, max) {	10✔
121	return await getSortedSetRangeByScore(key, start, count, min, max, 1, false);	54✔
122	};
123
124	module.getSortedSetRevRangeByScore = async function (key, start, count, max, min) {	10✔
125	return await getSortedSetRangeByScore(key, start, count, min, max, -1, false);	136✔
126	};
127
128	module.getSortedSetRangeByScoreWithScores = async function (key, start, count, min, max) {	10✔
129	return await getSortedSetRangeByScore(key, start, count, min, max, 1, true);	24✔
130	};
131
132	module.getSortedSetRevRangeByScoreWithScores = async function (key, start, count, max, min) {	10✔
133	return await getSortedSetRangeByScore(key, start, count, min, max, -1, true);	154✔
134	};
135
136	async function getSortedSetRangeByScore(key, start, count, min, max, sort, withScores) {
137	if (parseInt(count, 10) === 0) {	368✔
138	return [];	2✔
139	}
140	const stop = (parseInt(count, 10) === -1) ? -1 : (start + count - 1);	366✔
141	return await getSortedSetRange(key, start, stop, min, max, sort, withScores);	366✔
142	}
143
144	module.sortedSetCount = async function (key, min, max) {	10✔
145	if (!key) {	560!
146	return;	×
147	}
148
149	const query = { _key: key };	560✔
150	if (min !== '-inf') {	560✔
151	query.score = { $gte: min };	378✔
152	}
153	if (max !== '+inf') {	560✔
154	query.score = query.score \|\| {};	188✔
155	query.score.$lte = max;	188✔
156	}
157
158	const count = await module.client.collection('objects').countDocuments(query);	560✔
159	return count \|\| 0;	560✔
160	};
161
162	module.sortedSetCard = async function (key) {	10✔
163	if (!key) {	3,797!
164	return 0;	×
165	}
166	const count = await module.client.collection('objects').countDocuments({ _key: key });	3,797✔
167	return parseInt(count, 10) \|\| 0;	3,797✔
168	};
169
170	module.sortedSetsCard = async function (keys) {	10✔
171	if (!Array.isArray(keys) \|\| !keys.length) {	832✔
172	return [];	120✔
173	}
174	const promises = keys.map(k => module.sortedSetCard(k));	954✔
175	return await Promise.all(promises);	712✔
176	};
177
178	module.sortedSetsCardSum = async function (keys) {	10✔
179	if (!keys \|\| (Array.isArray(keys) && !keys.length)) {	272✔
180	return 0;	20✔
181	}
182
183	const count = await module.client.collection('objects').countDocuments({ _key: Array.isArray(keys) ? { $in: keys } : keys });	252✔
184	return parseInt(count, 10) \|\| 0;	252✔
185	};
186
187	module.sortedSetRank = async function (key, value) {	10✔
188	return await getSortedSetRank(false, key, value);	138✔
189	};
190
191	module.sortedSetRevRank = async function (key, value) {	10✔
192	return await getSortedSetRank(true, key, value);	8✔
193	};
194
195	async function getSortedSetRank(reverse, key, value) {
196	if (!key) {	150!
197	return;	×
198	}
199	value = helpers.valueToString(value);	150✔
200	const score = await module.sortedSetScore(key, value);	150✔
201	if (score === null) {	150✔
202	return null;	30✔
203	}
204
205	return await module.client.collection('objects').countDocuments({	120✔
206	$or: [
207	{
208	_key: key,
209	score: reverse ? { $gt: score } : { $lt: score },	120✔
210	},
211	{
212	_key: key,
213	score: score,
214	value: reverse ? { $gt: value } : { $lt: value },	120✔
215	},
216	],
217	});
218	}
219
220	module.sortedSetsRanks = async function (keys, values) {	10✔
221	return await sortedSetsRanks(module.sortedSetRank, keys, values);	2✔
222	};
223
224	module.sortedSetsRevRanks = async function (keys, values) {	10✔
225	return await sortedSetsRanks(module.sortedSetRevRank, keys, values);	×
226	};
227
228	async function sortedSetsRanks(method, keys, values) {
229	if (!Array.isArray(keys) \|\| !keys.length) {	2!
230	return [];	×
231	}
232	const data = new Array(values.length);	2✔
233	for (let i = 0; i < values.length; i += 1) {	2✔
234	data[i] = { key: keys[i], value: values[i] };	4✔
235	}
236	const promises = data.map(item => method(item.key, item.value));	4✔
237	return await Promise.all(promises);	2✔
238	}
239
240	module.sortedSetRanks = async function (key, values) {	10✔
241	return await sortedSetRanks(false, key, values);	12✔
242	};
243
244	module.sortedSetRevRanks = async function (key, values) {	10✔
245	return await sortedSetRanks(true, key, values);	2✔
246	};
247
248	async function sortedSetRanks(reverse, key, values) {
249	if (values.length === 1) {	14✔
250	return [await getSortedSetRank(reverse, key, values[0])];	4✔
251	}
252	const sortedSet = await module[reverse ? 'getSortedSetRevRange' : 'getSortedSetRange'](key, 0, -1);	10✔
253	return values.map((value) => {	10✔
254	if (!value) {	28!
255	return null;	×
256	}
257	const index = sortedSet.indexOf(value.toString());	28✔
258	return index !== -1 ? index : null;	28✔
259	});
260	}
261
262	module.sortedSetScore = async function (key, value) {	10✔
263	if (!key) {	6,145✔
264	return null;	2✔
265	}
266	value = helpers.valueToString(value);	6,143✔
267	const result = await module.client.collection('objects').findOne({ _key: key, value: value }, { projection: { _id: 0, _key: 0, value: 0 } });	6,143✔
268	return result ? result.score : null;	6,143✔
269	};
270
271	module.sortedSetsScore = async function (keys, value) {	10✔
272	if (!Array.isArray(keys) \|\| !keys.length) {	630✔
273	return [];	2✔
274	}
275	value = helpers.valueToString(value);	628✔
276	const result = await module.client.collection('objects').find({ _key: { $in: keys }, value: value }, { projection: { _id: 0, value: 0 } }).toArray();	628✔
277	const map = {};	628✔
278	result.forEach((item) => {	628✔
279	if (item) {	72!
280	map[item._key] = item;	72✔
281	}
282	});
283
284	return keys.map(key => (map[key] ? map[key].score : null));	1,384✔
285	};
286
287	module.sortedSetScores = async function (key, values) {	10✔
288	if (!key) {	3,358!
289	return null;	×
290	}
291	if (!values.length) {	3,358✔
292	return [];	66✔
293	}
294	values = values.map(helpers.valueToString);	3,292✔
295	const result = await module.client.collection('objects').find({ _key: key, value: { $in: values } }, { projection: { _id: 0, _key: 0 } }).toArray();	3,292✔
296
297	const valueToScore = {};	3,292✔
298	result.forEach((item) => {	3,292✔
299	if (item) {	2,419!
300	valueToScore[item.value] = item.score;	2,419✔
301	}
302	});
303
304	return values.map(v => (utils.isNumber(valueToScore[v]) ? valueToScore[v] : null));	37,568✔
305	};
306
307	module.isSortedSetMember = async function (key, value) {	10✔
308	if (!key) {	2,557!
309	return;	×
310	}
311	value = helpers.valueToString(value);	2,557✔
312	const result = await module.client.collection('objects').findOne({	2,557✔
313	_key: key, value: value,
314	}, {
315	projection: { _id: 0, value: 1 },
316	});
317	return !!result;	2,557✔
318	};
319
320	module.isSortedSetMembers = async function (key, values) {	10✔
321	if (!key) {	3,458!
322	return;	×
323	}
324	if (!values.length) {	3,458✔
325	return [];	146✔
326	}
327	values = values.map(helpers.valueToString);	3,312✔
328	const results = await module.client.collection('objects').find({	3,312✔
329	_key: key, value: { $in: values },
330	}, {
331	projection: { _id: 0, value: 1 },
332	}).toArray();
333
334	const isMember = {};	3,312✔
335	results.forEach((item) => {	3,312✔
336	if (item) {	7,659!
337	isMember[item.value] = true;	7,659✔
338	}
339	});
340
341	return values.map(value => !!isMember[value]);	12,293✔
342	};
343
344	module.isMemberOfSortedSets = async function (keys, value) {	10✔
345	if (!Array.isArray(keys) \|\| !keys.length) {	3,950✔
346	return [];	2✔
347	}
348	value = helpers.valueToString(value);	3,948✔
349	const results = await module.client.collection('objects').find({	3,948✔
350	_key: { $in: keys }, value: value,
351	}, {
352	projection: { _id: 0, _key: 1, value: 1 },
353	}).toArray();
354
355	const isMember = {};	3,948✔
356	results.forEach((item) => {	3,948✔
357	if (item) {	1,904!
358	isMember[item._key] = true;	1,904✔
359	}
360	});
361
362	return keys.map(key => !!isMember[key]);	19,293✔
363	};
364
365	module.getSortedSetMembers = async function (key) {	10✔
366	const data = await module.getSortedSetsMembers([key]);	2,024✔
367	return data && data[0];	2,024✔
368	};
369
370	module.getSortedSetsMembers = async function (keys) {	10✔
371	if (!Array.isArray(keys) \|\| !keys.length) {	3,404✔
372	return [];	44✔
373	}
374	const arrayOfKeys = keys.length > 1;	3,360✔
375	const projection = { _id: 0, value: 1 };	3,360✔
376	if (arrayOfKeys) {	3,360✔
377	projection._key = 1;	276✔
378	}
379	const data = await module.client.collection('objects').find({	3,360✔
380	_key: arrayOfKeys ? { $in: keys } : keys[0],	3,360✔
381	}, { projection: projection }).toArray();
382
383	if (!arrayOfKeys) {	3,360✔
384	return [data.map(item => item.value)];	3,084✔
385	}
386	const sets = {};	276✔
387	data.forEach((item) => {	276✔
388	sets[item._key] = sets[item._key] \|\| [];	2,520✔
389	sets[item._key].push(item.value);	2,520✔
390	});
391
392	return keys.map(k => sets[k] \|\| []);	2,306✔
393	};
394
395	module.sortedSetIncrBy = async function (key, increment, value) {	10✔
396	if (!key) {	1,321!
397	return;	×
398	}
399	const data = {};	1,321✔
400	value = helpers.valueToString(value);	1,321✔
401	data.score = parseFloat(increment);	1,321✔
402
403	try {	1,321✔
404	const result = await module.client.collection('objects').findOneAndUpdate({	1,321✔
405	_key: key,
406	value: value,
407	}, {
408	$inc: data,
409	}, {
410	returnDocument: 'after',
411	upsert: true,
412	});
413	return result && result.value ? result.value.score : null;	1,321!
414	} catch (err) {
415	// if there is duplicate key error retry the upsert
416	// https://github.com/NodeBB/NodeBB/issues/4467
417	// https://jira.mongodb.org/browse/SERVER-14322
418	// https://docs.mongodb.org/manual/reference/command/findAndModify/#upsert-and-unique-index
UNCOV 419	if (err && err.message.startsWith('E11000 duplicate key error')) {	×
UNCOV 420	return await module.sortedSetIncrBy(key, increment, value);	×
421	}
422	throw err;	×
423	}
424	};
425
426	module.sortedSetIncrByBulk = async function (data) {	10✔
427	const bulk = module.client.collection('objects').initializeUnorderedBulkOp();	34✔
428	data.forEach((item) => {	34✔
429	bulk.find({ _key: item[0], value: helpers.valueToString(item[2]) })	66✔
430	.upsert()
431	.update({ $inc: { score: parseFloat(item[1]) } });
432	});
433	await bulk.execute();	34✔
434	const result = await module.client.collection('objects').find({	34✔
435	_key: { $in: _.uniq(data.map(i => i[0])) },	66✔
436	value: { $in: _.uniq(data.map(i => i[2])) },	66✔
437	}, {
438	projection: { _id: 0, _key: 1, value: 1, score: 1 },
439	}).toArray();
440
441	const map = {};	34✔
442	result.forEach((item) => {	34✔
443	map[`${item._key}:${item.value}`] = item.score;	80✔
444	});
445	return data.map(item => map[`${item[0]}:${item[2]}`]);	66✔
446	};
447
448	module.getSortedSetRangeByLex = async function (key, min, max, start, count) {	10✔
449	return await sortedSetLex(key, min, max, 1, start, count);	44✔
450	};
451
452	module.getSortedSetRevRangeByLex = async function (key, max, min, start, count) {	10✔
453	return await sortedSetLex(key, min, max, -1, start, count);	10✔
454	};
455
456	module.sortedSetLexCount = async function (key, min, max) {	10✔
457	const data = await sortedSetLex(key, min, max, 1, 0, 0);	8✔
458	return data ? data.length : null;	8!
459	};
460
461	async function sortedSetLex(key, min, max, sort, start, count) {
462	const query = { _key: key };	62✔
463	start = start !== undefined ? start : 0;	62✔
464	count = count !== undefined ? count : 0;	62✔
465	buildLexQuery(query, min, max);	62✔
466
467	const data = await module.client.collection('objects').find(query, { projection: { _id: 0, value: 1 } })	62✔
468	.sort({ value: sort })
469	.skip(start)
470	.limit(count === -1 ? 0 : count)	62✔
471	.toArray();
472
473	return data.map(item => item && item.value);	148✔
474	}
475
476	module.sortedSetRemoveRangeByLex = async function (key, min, max) {	10✔
477	const query = { _key: key };	8✔
478	buildLexQuery(query, min, max);	8✔
479
480	await module.client.collection('objects').deleteMany(query);	8✔
481	};
482
483	function buildLexQuery(query, min, max) {
484	if (min !== '-') {	70✔
485	if (min.match(/^\(/)) {	44✔
486	query.value = { $gt: min.slice(1) };	8✔
487	} else if (min.match(/^\[/)) {	36✔
488	query.value = { $gte: min.slice(1) };	8✔
489	} else {
490	query.value = { $gte: min };	28✔
491	}
492	}
493	if (max !== '+') {	70✔
494	query.value = query.value \|\| {};	44!
495	if (max.match(/^\(/)) {	44✔
496	query.value.$lt = max.slice(1);	8✔
497	} else if (max.match(/^\[/)) {	36✔
498	query.value.$lte = max.slice(1);	8✔
499	} else {
500	query.value.$lte = max;	28✔
501	}
502	}
503	}
504
505	module.getSortedSetScan = async function (params) {	10✔
506	const project = { _id: 0, value: 1 };	16✔
507	if (params.withScores) {	16✔
508	project.score = 1;	2✔
509	}
510
511	const match = helpers.buildMatchQuery(params.match);	16✔
512	let regex;
513	try {	16✔
514	regex = new RegExp(match);	16✔
515	} catch (err) {
516	return [];	×
517	}
518
519	const cursor = module.client.collection('objects').find({	16✔
520	_key: params.key, value: { $regex: regex },
521	}, { projection: project });
522
523	if (params.limit) {	16✔
524	cursor.limit(params.limit);	10✔
525	}
526
527	const data = await cursor.toArray();	16✔
528	if (!params.withScores) {	16✔
529	return data.map(d => d.value);	24✔
530	}
531	return data;	2✔
532	};
533
534	module.processSortedSet = async function (setKey, processFn, options) {	10✔
535	let done = false;	534✔
536	const ids = [];	534✔
537	const project = { _id: 0, _key: 0 };	534✔
538
539	if (!options.withScores) {	534✔
540	project.score = 0;	528✔
541	}
542	const cursor = await module.client.collection('objects').find({ _key: setKey }, { projection: project })	534✔
543	.sort({ score: 1 })
544	.batchSize(options.batch);
545
546	if (processFn && processFn.constructor && processFn.constructor.name !== 'AsyncFunction') {	534✔
547	processFn = util.promisify(processFn);	46✔
548	}
549
550	while (!done) {	534✔
551	/* eslint-disable no-await-in-loop */
552	const item = await cursor.next();	4,640✔
553	if (item === null) {	4,640✔
554	done = true;	534✔
555	} else {
556	ids.push(options.withScores ? item : item.value);	4,106✔
557	}
558
559	if (ids.length >= options.batch \|\| (done && ids.length !== 0)) {	4,640✔
560	await processFn(ids);	146✔
561
562	ids.length = 0;	146✔
563	if (options.interval) {	146✔
564	await sleep(options.interval);	48✔
565	}
566	}
567	}
568	};
569	};

CMU-17313Q / fall23-nodebb-generation-z / 6222586690

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous