nodebb-plugin-mentions 2.14.1 → 3.0.0

package/library.js

@@ -1,55 +1,54 @@
+/* eslint-disable no-await-in-loop */
+
 'use strict';
 
-var	async = require('async');
-var winston = module.parent.require('winston');
-var XRegExp = require('xregexp');
-var validator = require('validator');
-var nconf = module.parent.require('nconf');
-
-var db = require.main.require('./src/database');
-var api = require.main.require('./src/api');
-var Topics = require.main.require('./src/topics');
-var posts = require.main.require('./src/posts');
-var User = require.main.require('./src/user');
-var Groups = require.main.require('./src/groups');
-var Notifications = require.main.require('./src/notifications');
-var Privileges = require.main.require('./src/privileges');
-var plugins = require.main.require('./src/plugins');
-var Meta = require.main.require('./src/meta');
-var slugify = require.main.require('./src/slugify');
-var batch = require.main.require('./src/batch');
-const utils = require.main.require('./public/src/utils');
-
-var SocketPlugins = require.main.require('./src/socket.io/plugins');
+const _ = require('lodash');
+const XRegExp = require('xregexp');
+const validator = require('validator');
+const entitiesDecode = require('html-entities').decode;
+
+const nconf = require.main.require('nconf');
+const winston = require.main.require('winston');
+
+const db = require.main.require('./src/database');
+const api = require.main.require('./src/api');
+const Topics = require.main.require('./src/topics');
+const posts = require.main.require('./src/posts');
+const User = require.main.require('./src/user');
+const Groups = require.main.require('./src/groups');
+const Notifications = require.main.require('./src/notifications');
+const Privileges = require.main.require('./src/privileges');
+const plugins = require.main.require('./src/plugins');
+const Meta = require.main.require('./src/meta');
+const slugify = require.main.require('./src/slugify');
+const batch = require.main.require('./src/batch');
+const utils = require.main.require('./src/utils');
+const SocketPlugins = require.main.require('./src/socket.io/plugins');
 
 const utility = require('./lib/utility');
 
-var regex = XRegExp('(?:^|\\s|\\>|;)(@[\\p{L}\\d\\-_.]+)', 'g');
-var isLatinMention = /@[\w\d\-_.]+$/;
-var removePunctuationSuffix = function(string) {
-	return string.replace(/[!?.]*$/, '');
-};
-var Entities = require('html-entities').XmlEntities;
-var entities = new Entities();
-
-var Mentions = {
-	_settings: {},
-	_defaults: {
-		disableFollowedTopics: 'off',
-		autofillGroups: 'off',
-		disableGroupMentions: '[]',
-		overrideIgnores: 'off',
-		display: '',
-	}
+const regex = XRegExp('(?:^|\\s|\\>|;)(@[\\p{L}\\d\\-_.]+)', 'g');
+const isLatinMention = /@[\w\d\-_.]+$/;
+
+const Mentions = module.exports;
+
+Mentions._settings = {};
+Mentions._defaults = {
+	disableFollowedTopics: 'off',
+	autofillGroups: 'off',
+	disableGroupMentions: '[]',
+	overrideIgnores: 'off',
+	display: '',
 };
+
 SocketPlugins.mentions = {};
 
 Mentions.init = async (data) => {
-	var hostMiddleware = require.main.require('./src/middleware');
-	var controllers = require('./controllers');
+	const hostMiddleware = require.main.require('./src/middleware');
+	const routeHelpers = require.main.require('./src/routes/helpers');
+	const controllers = require('./controllers');
 
-	data.router.get('/admin/plugins/mentions', hostMiddleware.admin.buildHeader, controllers.renderAdminPage);
-	data.router.get('/api/admin/plugins/mentions', controllers.renderAdminPage);
+	routeHelpers.setupAdminPageRoute(data.router, '/admin/plugins/mentions', hostMiddleware, [], controllers.renderAdminPage);
 
 	// Retrieve settings
 	Object.assign(Mentions._settings, Mentions._defaults, await Meta.settings.get('mentions'));
@@ -58,14 +57,14 @@ Mentions.init = async (data) => {
 Mentions.addAdminNavigation = async (header) => {
 	header.plugins.push({
 		route: '/plugins/mentions',
-		name: 'Mentions'
+		name: 'Mentions',
 	});
 
 	return header;
 };
 
 function getNoMentionGroups() {
-	var noMentionGroups = ['registered-users', 'guests'];
+	let noMentionGroups = ['registered-users', 'verified-users', 'unverified-users', 'guests'];
 	try {
 		noMentionGroups = noMentionGroups.concat(JSON.parse(Mentions._settings.disableGroupMentions));
 	} catch (err) {
@@ -74,105 +73,114 @@ function getNoMentionGroups() {
 	return noMentionGroups;
 }
 
-Mentions.notify = function(data) {
-	var postData = data.post;
-	var cleanedContent = Mentions.clean(postData.content, true, true, true);
-	var matches = cleanedContent.match(regex);
-
+Mentions.notify = async function (data) {
+	const postData = data.post;
+	const postOwner = parseInt(postData.uid, 10);
+	const cleanedContent = Mentions.clean(postData.content, true, true, true);
+	let matches = cleanedContent.match(regex);
 	if (!matches) {
 		return;
 	}
 
-	var noMentionGroups = getNoMentionGroups();
+	const noMentionGroups = getNoMentionGroups();
+	matches = _.uniq(matches.map(match => slugify(match))).filter(match => match && !noMentionGroups.includes(match));
+	if (!matches.length) {
+		return;
+	}
 
-	matches = matches.map(function(match) {
-		return slugify(match);
-	}).filter(function(match, index, array) {
-		return match && array.indexOf(match) === index && noMentionGroups.indexOf(match) === -1;
-	});
+	const [uidsToNotify, groupsToNotify] = await Promise.all([
+		getUidsToNotify(matches),
+		getGroupsToNotify(matches),
+	]);
 
-	if (!matches.length) {
+	if (!uidsToNotify.length && !groupsToNotify.length) {
 		return;
 	}
 
-	async.parallel({
-		userRecipients: function(next) {
-			async.filter(matches, User.existsBySlug, next);
-		},
-		groupRecipients: function(next) {
-			async.filter(matches, Groups.existsBySlug, next);
-		}
-	}, function(err, results) {
-		if (err) {
-			return;
-		}
+	const [topic, author, topicFollowers] = await Promise.all([
+		Topics.getTopicFields(postData.tid, ['title', 'cid']),
+		User.getUserField(postData.uid, 'username'),
+		Mentions._settings.disableFollowedTopics === 'on' ? Topics.getFollowers(postData.tid) : [],
+	]);
 
-		if (!results.userRecipients.length && !results.groupRecipients.length) {
-			return;
-		}
+	const title = entitiesDecode(topic.title);
+	const titleEscaped = title.replace(/%/g, '%').replace(/,/g, ',');
 
-		async.parallel({
-			topic: function(next) {
-				Topics.getTopicFields(postData.tid, ['title', 'cid'], next);
-			},
-			author: function(next) {
-				User.getUserField(postData.uid, 'username', next);
-			},
-			uids: function(next) {
-				async.map(results.userRecipients, function(slug, next) {
-					User.getUidByUserslug(slug, next);
-				}, next);
-			},
-			groupData: function(next) {
-				getGroupMemberUids(results.groupRecipients, next);
-			},
-			topicFollowers: function(next) {
-				if (Mentions._settings.disableFollowedTopics === 'on') {
-					Topics.getFollowers(postData.tid, next);
-				} else {
-					next(null, []);
-				}
-			}
-		}, async (err, results) => {
-			if (err) {
-				return;
-			}
+	let uids = uidsToNotify.filter(
+		uid => parseInt(uid, 10) !== postOwner && !topicFollowers.includes(uid)
+	);
 
-			var title = entities.decode(results.topic.title);
-			var titleEscaped = title.replace(/%/g, '%').replace(/,/g, ',');
+	if (Mentions._settings.privilegedDirectReplies === 'on') {
+		const toPid = await posts.getPostField(data.post.pid, 'toPid');
+		uids = await filterPrivilegedUids(uids, data.post.cid, toPid);
+	}
 
-			var uids = results.uids.filter(function(uid, index, array) {
-				return array.indexOf(uid) === index && parseInt(uid, 10) !== parseInt(postData.uid, 10) && !results.topicFollowers.includes(uid.toString());
-			});
+	const groupMemberUids = {};
+	groupsToNotify.forEach((groupData) => {
+		groupData.members = groupData.members.filter((uid) => {
+			if (!uid || groupMemberUids[uid]) {
+				return false;
+			}
+			groupMemberUids[uid] = 1;
+			return !uids.includes(uid) &&
+				parseInt(uid, 10) !== postOwner &&
+				!topicFollowers.includes(uid);
+		});
+	});
+
+	const filteredUids = await filterUidsAlreadyMentioned(uids, postData.pid);
+	if (filteredUids.length) {
+		await sendNotificationToUids(postData, filteredUids, 'user', `[[notifications:user_mentioned_you_in, ${author}, ${titleEscaped}]]`);
+		await db.setAdd(`mentions:pid:${postData.pid}:uids`, filteredUids);
+	}
 
-			if (Mentions._settings.privilegedDirectReplies === 'on') {
-				const toPid = await posts.getPostField(data.post.pid, 'toPid');
-				uids = await filterPrivilegedUids(uids, data.post.cid, toPid);
+	for (let i = 0; i < groupsToNotify.length; ++i) {
+		if (groupsToNotify[i] && groupsToNotify[i].name && groupsToNotify[i].members) {
+			const memberUids = groupsToNotify[i].members;
+			const groupName = groupsToNotify[i].name;
+			const groupMentionSent = await db.isSetMember(`mentions:pid:${postData.pid}:groups`, groupName);
+			if (!groupMentionSent && memberUids.length) {
+				await sendNotificationToUids(postData, memberUids, groupName, `[[notifications:user_mentioned_group_in, ${author} , ${groupName}, ${titleEscaped}]]`);
+				await db.setAdd(`mentions:pid:${postData.pid}:groups`, groupName);
 			}
+		}
+	}
+};
 
-			var groupMemberUids = {};
-			results.groupData.groupNames.forEach(function(groupName, index) {
-				results.groupData.groupMembers[index] = results.groupData.groupMembers[index].filter(function(uid) {
-					if (!uid || groupMemberUids[uid]) {
-						return false;
-					}
-					groupMemberUids[uid] = 1;
-					return !uids.includes(uid) &&
-						parseInt(uid, 10) !== parseInt(postData.uid, 10) &&
-						!results.topicFollowers.includes(uid.toString());
-				});
-			});
+async function getUidsToNotify(matches) {
+	const uids = await db.sortedSetScores('userslug:uid', matches);
+	return _.uniq(uids.filter(Boolean).map(String));
+}
 
-			sendNotificationToUids(postData, uids, 'user', '[[notifications:user_mentioned_you_in, ' + results.author + ', ' + titleEscaped + ']]');
+async function getGroupsToNotify(matches) {
+	if (!matches.length) {
+		return [];
+	}
+	const groupNames = Object.values(await db.getObjectFields('groupslug:groupname', matches));
+	const groupMembers = await Promise.all(groupNames.map(async (groupName) => {
+		if (!groupName) {
+			return [];
+		}
+		return db.getSortedSetRange(`group:${groupName}:members`, 0, 999);
+	}));
+	return groupNames.map((groupName, i) => ({
+		name: groupName,
+		members: groupMembers[i],
+	}));
+}
 
-			results.groupData.groupNames.forEach(function(groupName, index) {
-				var memberUids = results.groupData.groupMembers[index];
-				sendNotificationToUids(postData, memberUids, groupName, '[[notifications:user_mentioned_group_in, ' + results.author + ', ' + groupName + ', ' + titleEscaped + ']]');
-			});
-		});
-	});
+Mentions.actionPostPurge = async (hookData) => {
+	await db.deleteAll([
+		`mentions:pid:${hookData.postData.pid}:uids`,
+		`mentions:pid:${hookData.postData.pid}:groups`,
+	]);
 };
 
+async function filterUidsAlreadyMentioned(uids, pid) {
+	const isMember = await db.isSetMembers(`mentions:pid:${pid}:uids`, uids);
+	return uids.filter((uid, index) => !isMember[index]);
+}
+
 Mentions.addFilters = async (data) => {
 	data.regularFilters.push({ name: '[[notifications:mentions]]', filter: 'mention' });
 	return data;
@@ -190,109 +198,47 @@ Mentions.addFields = async (data) => {
 	return data;
 };
 
-function sendNotificationToUids(postData, uids, nidType, notificationText) {
+async function sendNotificationToUids(postData, uids, nidType, notificationText) {
 	if (!uids.length) {
 		return;
 	}
 
-	var filteredUids = [];
-	var notification;
-	async.waterfall([
-		function (next) {
-			createNotification(postData, nidType, notificationText, next);
-		},
-		function (_notification, next) {
-			notification = _notification;
-			if (!notification) {
-				return next();
-			}
-
-			batch.processArray(uids, function (uids, next) {
-				async.waterfall([
-					function(next) {
-						Privileges.topics.filterUids('read', postData.tid, uids, next);
-					},
-					function(_uids, next) {
-						if (Mentions._settings.overrideIgnores === 'on') {
-							return setImmediate(next, null, _uids);
-						}
-
-						Topics.filterIgnoringUids(postData.tid, _uids, next);
-					},
-					function (_uids, next) {
-						// Filter out uids that have already been notified for this pid
-						db.isSortedSetMembers('mentions:sent:' + postData.pid, _uids, function (err, exists) {
-							next(err, _uids.filter((uid, idx) => !exists[idx]))
-						});
-					},
-					function(_uids, next) {
-						if (!_uids.length) {
-							return next();
-						}
-
-						filteredUids = filteredUids.concat(_uids);
-
-						next();
-					}
-				], next);
-			}, {
-				interval: 1000,
-				batch: 500,
-			}, next);
-		},
-	], function (err) {
-		if (err) {
-			return winston.error(err);
-		}
+	const filteredUids = [];
+	const notification = await createNotification(postData, nidType, notificationText);
+	if (!notification) {
+		return;
+	}
 
-		if (notification && filteredUids.length) {
-			plugins.hooks.fire('action:mentions.notify', { notification, uids: filteredUids });
-			Notifications.push(notification, filteredUids, function () {
-				const dates = filteredUids.map(() => Date.now());
-				db.sortedSetAdd('mentions:sent:' + postData.pid, dates, filteredUids);
-			});
+	await batch.processArray(uids, async (uids) => {
+		uids = await Privileges.topics.filterUids('read', postData.tid, uids);
+		if (Mentions._settings.overrideIgnores !== 'on') {
+			uids = await Topics.filterIgnoringUids(postData.tid, uids);
 		}
+		filteredUids.push(...uids);
+	}, {
+		interval: 1000,
+		batch: 500,
 	});
-}
 
-function createNotification(postData, nidType, notificationText, callback) {
-	Topics.getTopicField(postData.tid, 'title', function (err, title) {
-		if (err) {
-			return callback(err);
-		}
-		if (title) {
-			title = utils.decodeHTMLEntities(title);
-		}
-		Notifications.create({
-			type: 'mention',
-			bodyShort: notificationText,
-			bodyLong: postData.content,
-			nid: 'tid:' + postData.tid + ':pid:' + postData.pid + ':uid:' + postData.uid + ':' + nidType,
-			pid: postData.pid,
-			tid: postData.tid,
-			from: postData.uid,
-			path: '/post/' + postData.pid,
-			topicTitle: title,
-			importance: 6,
-		}, callback);
-	});
+	if (notification && filteredUids.length) {
+		plugins.hooks.fire('action:mentions.notify', { notification, uids: filteredUids });
+		Notifications.push(notification, filteredUids);
+	}
 }
 
-function getGroupMemberUids(groupRecipients, callback) {
-	async.map(groupRecipients, function(slug, next) {
-		Groups.getGroupNameByGroupSlug(slug, next);
-	}, function(err, groupNames) {
-		if (err) {
-			return callback(err);
-		}
-		async.map(groupNames, function(groupName, next) {
-			Groups.getMembers(groupName, 0, -1, next);
-		}, function(err, groupMembers) {
-			if (err) {
-				return callback(err);
-			}
-			callback(null, {groupNames: groupNames, groupMembers: groupMembers});
-		});
+async function createNotification(postData, nidType, notificationText) {
+	const title = await Topics.getTopicField(postData.tid, 'title');
+	return await Notifications.create({
+		type: 'mention',
+		bodyShort: notificationText,
+		bodyLong: postData.content,
+		nid: `tid:${postData.tid}:pid:${postData.pid}:uid:${postData.uid}:${nidType}`,
+		pid: postData.pid,
+		tid: postData.tid,
+		from: postData.uid,
+		path: `/post/${postData.pid}`,
+		topicTitle: title ? utils.decodeHTMLEntities(title) : title,
+		importance: 6,
 	});
 }
 
@@ -306,11 +252,15 @@ Mentions.parsePost = async (data) => {
 	return data;
 };
 
+function removePunctuationSuffix(string) {
+	return string.replace(/[!?.]*$/, '');
+}
+
 Mentions.parseRaw = async (content) => {
 	let splitContent = utility.split(content, false, false, true);
-	var matches = [];
-	splitContent.forEach(function(cleanedContent, i) {
-		if ((i & 1) === 0) {
+	let matches = [];
+	splitContent.forEach((cleanedContent, i) => {
+		if ((i % 2) === 0) {
 			matches = matches.concat(cleanedContent.match(regex) || []);
 		}
 	});
@@ -319,21 +269,18 @@ Mentions.parseRaw = async (content) => {
 		return content;
 	}
 
-	matches = matches.filter(function(cur, idx) {
-		// Eliminate duplicates
-		return idx === matches.indexOf(cur);
-	}).map(function(match) {
+	matches = _.uniq(matches).map((match) => {
 		/**
 		 *	Javascript-favour of regex does not support lookaround,
 		 *	so need to clean up the cruft by discarding everthing
 		 *	before the @
 		 */
-		var atIndex = match.indexOf('@');
+		const atIndex = match.indexOf('@');
 		return atIndex !== 0 ? match.slice(atIndex) : match;
 	});
 
 	await Promise.all(matches.map(async (match) => {
-		var slug = slugify(match.slice(1));
+		const slug = slugify(match.slice(1));
 		match = removePunctuationSuffix(match);
 
 		const uid = await User.getUidByUserslug(slug);
@@ -343,22 +290,22 @@ Mentions.parseRaw = async (content) => {
 		});
 
 		if (results.user.uid || results.groupExists) {
-			var regex = isLatinMention.test(match)
-				? new RegExp('(?:^|\\s|\>|;)' + match + '\\b', 'g')
-				: new RegExp('(?:^|\\s|\>|;)' + match, 'g');
+			const regex = isLatinMention.test(match) ?
+				new RegExp(`(?:^|\\s|\>|;)${match}\\b`, 'g') :
+				new RegExp(`(?:^|\\s|\>|;)${match}`, 'g');
 
 			let skip = false;
 
-			splitContent = splitContent.map(function(c, i) {
+			splitContent = splitContent.map((c, i) => {
 				// *Might* not be needed anymore? Check pls...
-				if (skip || (i & 1) === 1) {
+				if (skip || (i % 2) === 1) {
 					skip = c === '<code>';	// if code block detected, skip the content inside of it
 					return c;
 				}
-				return c.replace(regex, function(match) {
+				return c.replace(regex, (match) => {
 					// Again, cleaning up lookaround leftover bits
-					var atIndex = match.indexOf('@');
-					var plain = match.slice(0, atIndex);
+					const atIndex = match.indexOf('@');
+					const plain = match.slice(0, atIndex);
 					match = match.slice(atIndex);
 					if (results.user.uid) {
 						switch (Mentions._settings.display) {
@@ -371,9 +318,9 @@ Mentions.parseRaw = async (content) => {
 						}
 					}
 
-					var str = results.user.uid
-							? '<a class="plugin-mentions-user plugin-mentions-a" href="' + nconf.get('url') + '/uid/' + results.user.uid + '">' + match + '</a>'
-							: '<a class="plugin-mentions-group plugin-mentions-a" href="' + nconf.get('url') + '/groups/' + slug + '">' + match + '</a>';
+					const str = results.user.uid ?
+						`<a class="plugin-mentions-user plugin-mentions-a" href="${nconf.get('url')}/uid/${results.user.uid}">${match}</a>` :
+						`<a class="plugin-mentions-group plugin-mentions-a" href="${nconf.get('url')}/groups/${slug}">${match}</a>`;
 
 					return plain + str;
 				});
@@ -384,19 +331,17 @@ Mentions.parseRaw = async (content) => {
 	return splitContent.join('');
 };
 
-Mentions.clean = function(input, isMarkdown, stripBlockquote, stripCode) {
-	var split = utility.split(input, isMarkdown, stripBlockquote, stripCode);
-	split = split.filter(function(e, i) {
-		// only keep non-code/non-blockquote
-		return (i & 1) === 0;
-	});
+Mentions.clean = function (input, isMarkdown, stripBlockquote, stripCode) {
+	let split = utility.split(input, isMarkdown, stripBlockquote, stripCode);
+	// only keep non-code/non-blockquote
+	split = split.filter((el, i) => (i % 2) === 0);
 	return split.join('');
 };
 
 /*
 	Local utility methods
 */
-async function filterPrivilegedUids (uids, cid, toPid) {
+async function filterPrivilegedUids(uids, cid, toPid) {
 	let toPidUid;
 	if (toPid) {
 		toPidUid = await posts.getPostField(toPid, 'uid');
@@ -420,12 +365,12 @@ async function filterPrivilegedUids (uids, cid, toPid) {
 	return uids.filter(Boolean);
 }
 
-async function filterDisallowedFullnames (users) {
+async function filterDisallowedFullnames(users) {
 	const userSettings = await User.getMultipleUserSettings(users.map(user => user.uid));
 	return users.filter((user, index) => userSettings[index].showfullname);
 }
 
-async function stripDisallowedFullnames (users) {
+async function stripDisallowedFullnames(users) {
 	const userSettings = await User.getMultipleUserSettings(users.map(user => user.uid));
 	return users.map((user, index) => {
 		if (!userSettings[index].showfullname) {
@@ -441,36 +386,24 @@ async function stripDisallowedFullnames (users) {
 
 SocketPlugins.mentions.getTopicUsers = async (socket, data) => {
 	const uids = await Topics.getUids(data.tid);
-	const users =  await User.getUsers(uids);
+	const users = await User.getUsers(uids);
 	if (Meta.config.hideFullname) {
 		return users;
 	}
 	return stripDisallowedFullnames(users);
 };
 
-SocketPlugins.mentions.listGroups = function(socket, data, callback) {
+SocketPlugins.mentions.listGroups = async function () {
 	if (Mentions._settings.autofillGroups === 'off') {
-		return callback(null, []);
+		return [];
 	}
 
-	Groups.getGroups('groups:visible:createtime', 0, -1, function(err, groups) {
-		if (err) {
-			return callback(err);
-		}
-		var noMentionGroups = getNoMentionGroups();
-		groups = groups.filter(function(groupName) {
-			return groupName && !noMentionGroups.includes(groupName);
-		}).map(function(groupName) {
-			return validator.escape(groupName);
-		});
-		callback(null, groups);
-	});
+	const groups = await Groups.getGroups('groups:visible:createtime', 0, -1);
+	const noMentionGroups = getNoMentionGroups();
+	return groups.filter(g => g && !noMentionGroups.includes(g)).map(g => validator.escape(String(g)));
 };
 
 SocketPlugins.mentions.userSearch = async (socket, data) => {
-	// Transparently pass request through to socket user.search handler
-	const socketUser = require.main.require('./src/socket.io/user');
-
 	// Search by username
 	let { users } = await api.users.search(socket, data);
 
@@ -479,13 +412,13 @@ SocketPlugins.mentions.userSearch = async (socket, data) => {
 		users = await stripDisallowedFullnames(users);
 
 		// Search by fullname
-		let { users: fullnameUsers } = await api.users.search(socket, {query: data.query, searchBy: 'fullname'});
+		let { users: fullnameUsers } = await api.users.search(socket, { query: data.query, searchBy: 'fullname' });
 		// Hide results of users that do not allow their full name to be visible (prevents "enumeration attack")
 		fullnameUsers = await filterDisallowedFullnames(fullnameUsers);
 
 		// Merge results, filter duplicates (from username search, leave fullname results)
-		users = users.filter(userObj =>
-			fullnameUsers.filter(userObj2 => userObj.uid === userObj2.uid).length === 0
+		users = users.filter(
+			userObj => fullnameUsers.filter(userObj2 => userObj.uid === userObj2.uid).length === 0
 		).concat(fullnameUsers);
 	}
 
@@ -497,10 +430,9 @@ SocketPlugins.mentions.userSearch = async (socket, data) => {
 		const cid = Topics.getTopicField(data.composerObj.tid, 'cid');
 		const filteredUids = await filterPrivilegedUids(users.map(userObj => userObj.uid), cid, data.composerObj.toPid);
 
-		users = users.filter((userObj) => filteredUids.includes(userObj.uid));
+		users = users.filter(userObj => filteredUids.includes(userObj.uid));
 	}
 
 	return users;
 };
 
-module.exports = Mentions;