6676607949

Committed 28 Oct 2023 11:28AM UTC coverage: 84.982% (-0.03%) from 85.013%

Build # 6676607949

Build Type

Pull #79

github

Committed by

web-flow

Commit Message

Merge f90d9ae7d into 6e56c6956

Pull Request Pull Request #79: Integrating the JShint Tool

Run Details

10216 of 13255 branches covered (0.0%)

Branch coverage included in aggregate %.

23 of 26 new or added lines in 17 files covered. (88.46%)

5 existing lines in 3 files now uncovered.

22616 of 25379 relevant lines covered (89.11%)

3225.09 hits per line

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

88.07

/src/database/mongo/hash.js

'use strict';

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

    const cache = require('../cache').create('mongo');

    module.objectCache = cache;

    module.setObject = async function (key, data) {
        const isArray = Array.isArray(key);
        if (!key || !data || (isArray && !key.length)) {
            return;
        }

        const writeData = helpers.serializeData(data);
        if (!Object.keys(writeData).length) {
            return;
        }
        try {
            if (isArray) {
                const bulk = module.client.collection('objects').initializeUnorderedBulkOp();
                key.forEach(key => bulk.find({ _key: key }).upsert().updateOne({ $set: writeData }));
                await bulk.execute();
            } else {
                await module.client.collection('objects').updateOne({ _key: key }, { $set: writeData }, { upsert: true });
            }
        } catch (err) {
            if (err && err.message.startsWith('E11000 duplicate key error')) {
                return await module.setObject(key, data);
            }
            throw err;
        }

        cache.del(key);
    };

    module.setObjectBulk = async function (...args) {
        let data = args[0];
        if (!Array.isArray(data) || !data.length) {
            return;
        }
        if (Array.isArray(args[1])) {
            console.warn('[deprecated] db.setObjectBulk(keys, data) usage is deprecated, please use db.setObjectBulk(data)');
            // conver old format to new format for backwards compatibility
            data = args[0].map((key, i) => [key, args[1][i]]);
        }

        try {
            let bulk;
            data.forEach((item) => {
                const writeData = helpers.serializeData(item[1]);
                if (Object.keys(writeData).length) {
                    if (!bulk) {
                        bulk = module.client.collection('objects').initializeUnorderedBulkOp();
                    }
                    bulk.find({ _key: item[0] }).upsert().updateOne({ $set: writeData });
                }
            });
            if (bulk) {
                await bulk.execute();
            }
        } catch (err) {
            if (err && err.message.startsWith('E11000 duplicate key error')) {
                return await module.setObjectBulk(data);
            }
            throw err;
        }

        cache.del(data.map(item => item[0]));
    };

    module.setObjectField = async function (key, field, value) {
        if (!field) {
            return;
        }
        const data = {};
        data[field] = value;
        await module.setObject(key, data);
    };

    module.getObject = async function (key, fields = []) {
        if (!key) {
            return null;
        }

        const data = await module.getObjects([key], fields);
        return data && data.length ? data[0] : null;
    };

    module.getObjects = async function (keys, fields = []) {
        return await module.getObjectsFields(keys, fields);
    };

    module.getObjectField = async function (key, field) {
        if (!key) {
            return null;
        }
        const cachedData = {};
        cache.getUnCachedKeys([key], cachedData);
        if (cachedData[key]) {
            return cachedData[key].hasOwnProperty(field) ? cachedData[key][field] : null;
        }
        field = helpers.fieldToString(field);
        const item = await module.client.collection('objects').findOne({ _key: key }, { projection: { _id: 0, [field]: 1 } });
        if (!item) {
            return null;
        }
        return item.hasOwnProperty(field) ? item[field] : null;
    };

    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 [];
        }
        const cachedData = {};
        const unCachedKeys = cache.getUnCachedKeys(keys, cachedData);
        let data = [];
        if (unCachedKeys.length >= 1) {
            data = await module.client.collection('objects').find(
                { _key: unCachedKeys.length === 1 ? unCachedKeys[0] : { $in: unCachedKeys } },
                { projection: { _id: 0 } }
            ).toArray();
            data = data.map(helpers.deserializeData);
        }

        const map = helpers.toMap(data);
        unCachedKeys.forEach((key) => {
            cachedData[key] = map[key] || null;
            cache.set(key, cachedData[key]);
        });

        if (!Array.isArray(fields) || !fields.length) {
            return keys.map(key => (cachedData[key] ? { ...cachedData[key] } : null));
        }
        return keys.map((key) => {
            const item = cachedData[key] || {};
            const result = {};
            fields.forEach((field) => {
                result[field] = item[field] !== undefined ? item[field] : null;
            });
            return result;
        });
    };

    module.getObjectKeys = async function (key) {
        const data = await module.getObject(key);
        return data ? Object.keys(data) : [];
    };

    module.getObjectValues = async function (key) {
        const data = await module.getObject(key);
        return data ? Object.values(data) : [];
    };

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

        const data = {};
        fields.forEach((field) => {
            field = helpers.fieldToString(field);
            if (field) {
                data[field] = 1;
            }
        });

        const item = await module.client.collection('objects').findOne({ _key: key }, { projection: data });
        const results = fields.map(f => !!item && item[f] !== undefined && item[f] !== null);
        return results;
    };

    module.deleteObjectField = async function (key, field) {
        await module.deleteObjectFields(key, [field]);
    };

    module.deleteObjectFields = async function (key, fields) {
        if (!key || (Array.isArray(key) && !key.length) || !Array.isArray(fields) || !fields.length) {
            return;
        }
        fields = fields.filter(Boolean);
        if (!fields.length) {
            return;
        }

        const data = {};
        fields.forEach((field) => {
            field = helpers.fieldToString(field);
            data[field] = '';
        });
        if (Array.isArray(key)) {
            await module.client.collection('objects').updateMany({ _key: { $in: key } }, { $unset: data });
        } else {
            await module.client.collection('objects').updateOne({ _key: key }, { $unset: data });
        }

        cache.del(key);
    };

    module.incrObjectField = async function (key, field) {
        return await module.incrObjectFieldBy(key, field, 1);
    };

    module.decrObjectField = async function (key, field) {
        return await module.incrObjectFieldBy(key, field, -1);
    };

    module.incrObjectFieldBy = async function (key, field, value) {
        value = parseInt(value, 10);
        if (!key || isNaN(value)) {
            return null;
        }

        const increment = {};
        field = helpers.fieldToString(field);
        increment[field] = value;

        if (Array.isArray(key)) {
            const bulk = module.client.collection('objects').initializeUnorderedBulkOp();
            key.forEach((key) => {
                bulk.find({ _key: key }).upsert().update({ $inc: increment });
            });
            await bulk.execute();
            cache.del(key);
            const result = await module.getObjectsFields(key, [field]);
            return result.map(data => data && data[field]);
        }
        try {
            const result = await module.client.collection('objects').findOneAndUpdate({
                _key: key,
            }, {
                $inc: increment,
            }, {
                returnDocument: 'after',
                upsert: true,
            });
            cache.del(key);
            return result && result.value ? result.value[field] : 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.incrObjectFieldBy(key, field, value);
            }
            throw err;
        }
    };

    module.incrObjectFieldByBulk = async function (data) {
        if (!Array.isArray(data) || !data.length) {
            return;
        }

        const bulk = module.client.collection('objects').initializeUnorderedBulkOp();

        data.forEach((item) => {
            const increment = {};
            for (const [field, value] of Object.entries(item[1])) {
                increment[helpers.fieldToString(field)] = value;
            }
            bulk.find({ _key: item[0] }).upsert().update({ $inc: increment });
        });
        await bulk.execute();
        cache.del(data.map(item => item[0]));
    };
};

1	'use strict';
2
3	module.exports = function (module) {	10✔
4	const helpers = require('./helpers');	10✔
5
6	const cache = require('../cache').create('mongo');	10✔
7
8	module.objectCache = cache;	10✔
9
10	module.setObject = async function (key, data) {	10✔
11	const isArray = Array.isArray(key);	16,116✔
12	if (!key \|\| !data \|\| (isArray && !key.length)) {	16,116✔
13	return;	8✔
14	}
15
16	const writeData = helpers.serializeData(data);	16,108✔
17	if (!Object.keys(writeData).length) {	16,108✔
18	return;	4✔
19	}
20	try {	16,104✔
21	if (isArray) {	16,104✔
22	const bulk = module.client.collection('objects').initializeUnorderedBulkOp();	30✔
23	key.forEach(key => bulk.find({ _key: key }).upsert().updateOne({ $set: writeData }));	36✔
24	await bulk.execute();	30✔
25	} else {
26	await module.client.collection('objects').updateOne({ _key: key }, { $set: writeData }, { upsert: true });	16,074✔
27	}
28	} catch (err) {
29	if (err && err.message.startsWith('E11000 duplicate key error')) {	×
30	return await module.setObject(key, data);	×
31	}
32	throw err;	×
33	}
34
35	cache.del(key);	16,104✔
36	};
37
38	module.setObjectBulk = async function (...args) {	10✔
39	let data = args[0];	720✔
40	if (!Array.isArray(data) \|\| !data.length) {	720✔
41	return;	56✔
42	}
43	if (Array.isArray(args[1])) {	664!
44	console.warn('[deprecated] db.setObjectBulk(keys, data) usage is deprecated, please use db.setObjectBulk(data)');	×
45	// conver old format to new format for backwards compatibility
46	data = args[0].map((key, i) => [key, args[1][i]]);	×
47	}
48
49	try {	664✔
50	let bulk;
51	data.forEach((item) => {	664✔
52	const writeData = helpers.serializeData(item[1]);	792✔
53	if (Object.keys(writeData).length) {	792✔
54	if (!bulk) {	788✔
55	bulk = module.client.collection('objects').initializeUnorderedBulkOp();	662✔
56	}
57	bulk.find({ _key: item[0] }).upsert().updateOne({ $set: writeData });	788✔
58	}
59	});
60	if (bulk) {	664✔
61	await bulk.execute();	662✔
62	}
63	} catch (err) {
64	if (err && err.message.startsWith('E11000 duplicate key error')) {	×
65	return await module.setObjectBulk(data);	×
66	}
67	throw err;	×
68	}
69
70	cache.del(data.map(item => item[0]));	792✔
71	};
72
73	module.setObjectField = async function (key, field, value) {	10✔
74	if (!field) {	6,961!
75	return;	×
76	}
77	const data = {};	6,961✔
78	data[field] = value;	6,961✔
79	await module.setObject(key, data);	6,961✔
80	};
81
82	module.getObject = async function (key, fields = []) {	10✔
83	if (!key) {	3,368✔
84	return null;	2✔
85	}
86
87	const data = await module.getObjects([key], fields);	3,366✔
88	return data && data.length ? data[0] : null;	3,366!
89	};
90
91	module.getObjects = async function (keys, fields = []) {	10✔
92	return await module.getObjectsFields(keys, fields);	32,563✔
93	};
94
95	module.getObjectField = async function (key, field) {	10✔
96	if (!key) {	2,479✔
97	return null;	2✔
98	}
99	const cachedData = {};	2,477✔
100	cache.getUnCachedKeys([key], cachedData);	2,477✔
101	if (cachedData[key]) {	2,477✔
102	return cachedData[key].hasOwnProperty(field) ? cachedData[key][field] : null;	866✔
103	}
104	field = helpers.fieldToString(field);	1,611✔
105	const item = await module.client.collection('objects').findOne({ _key: key }, { projection: { _id: 0, [field]: 1 } });	1,611✔
106	if (!item) {	1,611✔
107	return null;	114✔
108	}
109	return item.hasOwnProperty(field) ? item[field] : null;	1,497✔
110	};
111
112	module.getObjectFields = async function (key, fields) {	10✔
113	if (!key) {	1,346✔
114	return null;	2✔
115	}
116	const data = await module.getObjectsFields([key], fields);	1,344✔
117	return data ? data[0] : null;	1,344!
118	};
119
120	module.getObjectsFields = async function (keys, fields) {	10✔
121	if (!Array.isArray(keys) \|\| !keys.length) {	45,731✔
122	return [];	1,573✔
123	}
124	const cachedData = {};	44,158✔
125	const unCachedKeys = cache.getUnCachedKeys(keys, cachedData);	44,158✔
126	let data = [];	44,158✔
127	if (unCachedKeys.length >= 1) {	44,158✔
128	data = await module.client.collection('objects').find(	14,847✔
129	{ _key: unCachedKeys.length === 1 ? unCachedKeys[0] : { $in: unCachedKeys } },	14,847✔
130	{ projection: { _id: 0 } }
131	).toArray();
132	data = data.map(helpers.deserializeData);	14,847✔
133	}
134
135	const map = helpers.toMap(data);	44,158✔
136	unCachedKeys.forEach((key) => {	44,158✔
137	cachedData[key] = map[key] \|\| null;	24,620✔
138	cache.set(key, cachedData[key]);	24,620✔
139	});
140
141	if (!Array.isArray(fields) \|\| !fields.length) {	44,158✔
142	return keys.map(key => (cachedData[key] ? { ...cachedData[key] } : null));	17,504✔
143	}
144	return keys.map((key) => {	29,967✔
145	const item = cachedData[key] \|\| {};	51,855✔
146	const result = {};	51,855✔
147	fields.forEach((field) => {	51,855✔
148	result[field] = item[field] !== undefined ? item[field] : null;	163,958✔
149	});
150	return result;	51,855✔
151	});
152	};
153
154	module.getObjectKeys = async function (key) {	10✔
155	const data = await module.getObject(key);	4✔
156	return data ? Object.keys(data) : [];	4✔
157	};
158
159	module.getObjectValues = async function (key) {	10✔
160	const data = await module.getObject(key);	4✔
161	return data ? Object.values(data) : [];	4✔
162	};
163
164	module.isObjectField = async function (key, field) {	10✔
165	const data = await module.isObjectFields(key, [field]);	4,512✔
166	return Array.isArray(data) && data.length ? data[0] : false;	4,512!
167	};
168
169	module.isObjectFields = async function (key, fields) {	10✔
170	if (!key) {	4,518!
171	return;	×
172	}
173
174	const data = {};	4,518✔
175	fields.forEach((field) => {	4,518✔
176	field = helpers.fieldToString(field);	4,526✔
177	if (field) {	4,526✔
178	data[field] = 1;	4,522✔
179	}
180	});
181
182	const item = await module.client.collection('objects').findOne({ _key: key }, { projection: data });	4,518✔
183	const results = fields.map(f => !!item && item[f] !== undefined && item[f] !== null);	4,526✔
184	return results;	4,518✔
185	};
186
187	module.deleteObjectField = async function (key, field) {	10✔
188	await module.deleteObjectFields(key, [field]);	790✔
189	};
190
191	module.deleteObjectFields = async function (key, fields) {	10✔
192	if (!key \|\| (Array.isArray(key) && !key.length) \|\| !Array.isArray(fields) \|\| !fields.length) {	1,366✔
193	return;	84✔
194	}
195	fields = fields.filter(Boolean);	1,282✔
196	if (!fields.length) {	1,282✔
197	return;	4✔
198	}
199
200	const data = {};	1,278✔
201	fields.forEach((field) => {	1,278✔
202	field = helpers.fieldToString(field);	1,524✔
203	data[field] = '';	1,524✔
204	});
205	if (Array.isArray(key)) {	1,278✔
206	await module.client.collection('objects').updateMany({ _key: { $in: key } }, { $unset: data });	12✔
207	} else {
208	await module.client.collection('objects').updateOne({ _key: key }, { $unset: data });	1,266✔
209	}
210
211	cache.del(key);	1,278✔
212	};
213
214	module.incrObjectField = async function (key, field) {	10✔
215	return await module.incrObjectFieldBy(key, field, 1);	6,826✔
216	};
217
218	module.decrObjectField = async function (key, field) {	10✔
219	return await module.incrObjectFieldBy(key, field, -1);	320✔
220	};
221
222	module.incrObjectFieldBy = async function (key, field, value) {	10✔
223	value = parseInt(value, 10);	9,692✔
224	if (!key \|\| isNaN(value)) {	9,692✔
225	return null;	2✔
226	}
227
228	const increment = {};	9,690✔
229	field = helpers.fieldToString(field);	9,690✔
230	increment[field] = value;	9,690✔
231
232	if (Array.isArray(key)) {	9,690✔
233	const bulk = module.client.collection('objects').initializeUnorderedBulkOp();	2,120✔
234	key.forEach((key) => {	2,120✔
235	bulk.find({ _key: key }).upsert().update({ $inc: increment });	11,350✔
236	});
237	await bulk.execute();	2,120✔
238	cache.del(key);	2,120✔
239	const result = await module.getObjectsFields(key, [field]);	2,120✔
240	return result.map(data => data && data[field]);	11,350✔
241	}
242	try {	7,570✔
243	const result = await module.client.collection('objects').findOneAndUpdate({	7,570✔
244	_key: key,
245	}, {
246	$inc: increment,
247	}, {
248	returnDocument: 'after',
249	upsert: true,
250	});
251	cache.del(key);	7,570✔
252	return result && result.value ? result.value[field] : null;	7,570!
253	} catch (err) {
254	// if there is duplicate key error retry the upsert
255	// https://github.com/NodeBB/NodeBB/issues/4467
256	// https://jira.mongodb.org/browse/SERVER-14322
257	// https://docs.mongodb.org/manual/reference/command/findAndModify/#upsert-and-unique-index
UNCOV 258	if (err && err.message.startsWith('E11000 duplicate key error')) {	×
UNCOV 259	return await module.incrObjectFieldBy(key, field, value);	×
260	}
261	throw err;	×
262	}
263	};
264
265	module.incrObjectFieldByBulk = async function (data) {	10✔
266	if (!Array.isArray(data) \|\| !data.length) {	30!
267	return;	×
268	}
269
270	const bulk = module.client.collection('objects').initializeUnorderedBulkOp();	30✔
271
272	data.forEach((item) => {	30✔
273	const increment = {};	88✔
274	for (const [field, value] of Object.entries(item[1])) {	88✔
275	increment[helpers.fieldToString(field)] = value;	90✔
276	}
277	bulk.find({ _key: item[0] }).upsert().update({ $inc: increment });	88✔
278	});
279	await bulk.execute();	30✔
280	cache.del(data.map(item => item[0]));	88✔
281	};
282	};

CMU-17313Q / fall23-nodebb-just-relax / 6676607949

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