nodebb-plugin-mentions 2.15.2 → 3.0.0

package/.eslintrc

@@ -0,0 +1,3 @@
+{
+	"extends": "nodebb/lib"
+}

package/controllers.js

@@ -1,14 +1,10 @@
-'use strict';
-
-var groups = require.main.require('./src/groups');
-
-var Controllers = module.exports;
-
-Controllers.renderAdminPage = function (req, res, next) {	
-	groups.getGroupsFromSet('groups:visible:createtime', 0, -1, function(err, groupData) {		
-		if (err) {
-			return next(err);
-		}
-		res.render('admin/plugins/mentions', { groups: groupData });
-	});
-};
+'use strict';
+
+const groups = require.main.require('./src/groups');
+
+const Controllers = module.exports;
+
+Controllers.renderAdminPage = async function (req, res) {
+	const groupData = await groups.getGroupsFromSet('groups:visible:createtime', 0, -1);
+	res.render('admin/plugins/mentions', { groups: groupData });
+};

package/lib/utility.js

@@ -1,16 +1,18 @@
-const Utility = module.exports;
-
-Utility.split = function(input, isMarkdown, splitBlockquote, splitCode) {
-	if (!input) {
-		return [];
-	}
-
-	var matchers = [isMarkdown ? '\\[.*?\\]\\(.*?\\)' : '<a\\s[\\s\\S]*?</a>(?=<[^>]+>)?'];
-	if (splitBlockquote) {
-		matchers.push(isMarkdown ? '^>.*$' : '^<blockquote>.*?</blockquote>');
-	}
-	if (splitCode) {
-		matchers.push(isMarkdown ? '`[^`\n]+`|```[\\s\\S]+```' : '<code[\\s\\S]*?</code>|<pre[\\s\\S]*?</pre>');
-	}
-	return input.split(new RegExp('(' + matchers.join('|') + ')', 'gm'));
-}
+'use strict';
+
+const Utility = module.exports;
+
+Utility.split = function (input, isMarkdown, splitBlockquote, splitCode) {
+	if (!input) {
+		return [];
+	}
+
+	const matchers = [isMarkdown ? '\\[.*?\\]\\(.*?\\)' : '<a\\s[\\s\\S]*?</a>(?=<[^>]+>)?'];
+	if (splitBlockquote) {
+		matchers.push(isMarkdown ? '^>.*$' : '^<blockquote>.*?</blockquote>');
+	}
+	if (splitCode) {
+		matchers.push(isMarkdown ? '`[^`\n]+`|```[\\s\\S]+```' : '<code[\\s\\S]*?</code>|<pre[\\s\\S]*?</pre>');
+	}
+	return input.split(new RegExp(`(${matchers.join('|')})`, 'gm'));
+};

package/library.js

@@ -1,54 +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 entitiesDecode = require('html-entities').decode;
-
-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'));
@@ -57,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', 'verified-users', 'unverified-users', 'guests'];
+	let noMentionGroups = ['registered-users', 'verified-users', 'unverified-users', 'guests'];
 	try {
 		noMentionGroups = noMentionGroups.concat(JSON.parse(Mentions._settings.disableGroupMentions));
 	} catch (err) {
@@ -73,121 +73,108 @@ 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();
-
-	matches = matches.map(function(match) {
-		return slugify(match);
-	}).filter(function(match, index, array) {
-		return match && array.indexOf(match) === index && noMentionGroups.indexOf(match) === -1;
-	});
-
+	const noMentionGroups = getNoMentionGroups();
+	matches = _.uniq(matches.map(match => slugify(match))).filter(match => match && !noMentionGroups.includes(match));
 	if (!matches.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;
-		}
-
-		if (!results.userRecipients.length && !results.groupRecipients.length) {
-			return;
-		}
-
-		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: async function() {
-				return await getGroupMemberUids(results.groupRecipients);
-			},
-			topicFollowers: function(next) {
-				if (Mentions._settings.disableFollowedTopics === 'on') {
-					Topics.getFollowers(postData.tid, next);
-				} else {
-					next(null, []);
-				}
-			}
-		}, async (err, results) => {
-			if (err) {
-				return;
-			}
+	const [uidsToNotify, groupsToNotify] = await Promise.all([
+		getUidsToNotify(matches),
+		getGroupsToNotify(matches),
+	]);
 
-			var title = entitiesDecode(results.topic.title);
-			var titleEscaped = title.replace(/%/g, '%').replace(/,/g, ',');
+	if (!uidsToNotify.length && !groupsToNotify.length) {
+		return;
+	}
 
-			var uids = results.uids.map(String).filter(function(uid, index, array) {
-				return array.indexOf(uid) === index && parseInt(uid, 10) !== parseInt(postData.uid, 10) && !results.topicFollowers.includes(uid);
-			});
+	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 (Mentions._settings.privilegedDirectReplies === 'on') {
-				const toPid = await posts.getPostField(data.post.pid, 'toPid');
-				uids = await filterPrivilegedUids(uids, data.post.cid, toPid);
-			}
+	const title = entitiesDecode(topic.title);
+	const titleEscaped = title.replace(/%/g, '%').replace(/,/g, ',');
 
-			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);
-				});
-			});
+	let uids = uidsToNotify.filter(
+		uid => parseInt(uid, 10) !== postOwner && !topicFollowers.includes(uid)
+	);
 
-			const filteredUids = await filterUidsAlreadyMentioned(uids, postData.pid);
+	if (Mentions._settings.privilegedDirectReplies === 'on') {
+		const toPid = await posts.getPostField(data.post.pid, 'toPid');
+		uids = await filterPrivilegedUids(uids, data.post.cid, toPid);
+	}
 
-			if (filteredUids.length) {
-				sendNotificationToUids(postData, filteredUids, 'user', '[[notifications:user_mentioned_you_in, ' + results.author + ', ' + titleEscaped + ']]');
-				await db.setAdd(`mentions:pid:${postData.pid}:uids`, filteredUids);
+	const groupMemberUids = {};
+	groupsToNotify.forEach((groupData) => {
+		groupData.members = groupData.members.filter((uid) => {
+			if (!uid || groupMemberUids[uid]) {
+				return false;
 			}
-
-			for (let i = 0; i < results.groupData.groupNames.length; ++i) {
-				const memberUids = results.groupData.groupMembers[i];
-				const groupName = results.groupData.groupNames[i];
-				const groupMentionSent = await db.isSetMember(`mentions:pid:${postData.pid}:groups`, groupName);
-				if (!groupMentionSent && memberUids.length) {
-					sendNotificationToUids(postData, memberUids, groupName, '[[notifications:user_mentioned_group_in, ' + results.author + ', ' + groupName + ', ' + titleEscaped + ']]');
-					await db.setAdd(`mentions:pid:${postData.pid}:groups`, groupName);
-				}
-			};
+			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);
+	}
+
+	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);
+			}
+		}
+	}
 };
 
+async function getUidsToNotify(matches) {
+	const uids = await db.sortedSetScores('userslug:uid', matches);
+	return _.uniq(uids.filter(Boolean).map(String));
+}
+
+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],
+	}));
+}
+
 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);
@@ -211,97 +198,48 @@ 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) {
-						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);
+	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);
+	}
 }
 
-async function getGroupMemberUids(groupRecipients) {
-	if (!groupRecipients.length) {
-		return { groupNames: [], groupMembers: [] };
-	}
-	const groupNames = Object.values(await db.getObjectFields('groupslug:groupname', groupRecipients));
-	const groupMembers = await Promise.all(groupNames.map(async (groupName) => {
-		if (!groupName) {
-			return [];
-		}
-		return db.getSortedSetRange(`group:${groupName}:members`, 0, 999);
-	}));
-	return { groupNames, 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,
+	});
 }
 
 Mentions.parsePost = async (data) => {
@@ -314,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) || []);
 		}
 	});
@@ -327,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);
@@ -351,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) {
@@ -379,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;
 				});
@@ -392,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');
@@ -428,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) {
@@ -449,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);
 
@@ -487,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);
 	}
 
@@ -505,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-mentions",
-  "version": "2.15.2",
+  "version": "3.0.0",
   "description": "NodeBB Plugin that allows users to mention other users by prepending an '@' sign to their username",
   "main": "library.js",
   "scripts": {
@@ -25,12 +25,15 @@
     "compatibility": "^1.15.0"
   },
   "dependencies": {
-    "async": "^2",
     "html-entities": "^2.3.2",
+    "lodash": "4.17.21",
     "validator": "^13.0.0",
     "xregexp": "^5.1.0"
   },
   "devDependencies": {
-    "mocha": "9.1.3"
+    "mocha": "9.1.3",
+    "eslint": "8.1.0",
+    "eslint-config-nodebb": "^0.0.3",
+    "eslint-plugin-import": "^2.24.2"
   }
 }

package/.jshintrc

@@ -1,86 +0,0 @@
-{
-    // JSHint Default Configuration File (as on JSHint website)
-    // See http://jshint.com/docs/ for more details
-
-    "maxerr" : 50, // {int} Maximum error before stopping
-
-    // Enforcing
-    "bitwise" : true, // true: Prohibit bitwise operators (&, |, ^, etc.)
-    "camelcase" : false, // true: Identifiers must be in camelCase
-    "curly" : true, // true: Require {} for every new block or scope
-    "eqeqeq" : true, // true: Require triple equals (===) for comparison
-    "forin" : true, // true: Require filtering for..in loops with obj.hasOwnProperty()
-    "immed" : false, // true: Require immediate invocations to be wrapped in parens e.g. `(function () { } ());`
-    "indent" : 4, // {int} Number of spaces to use for indentation
-    "latedef" : false, // true: Require variables/functions to be defined before being used
-    "newcap" : false, // true: Require capitalization of all constructor functions e.g. `new F()`
-    "noarg" : true, // true: Prohibit use of `arguments.caller` and `arguments.callee`
-    "noempty" : true, // true: Prohibit use of empty blocks
-    "nonew" : false, // true: Prohibit use of constructors for side-effects (without assignment)
-    "plusplus" : false, // true: Prohibit use of `++` & `--`
-    "quotmark" : false, // Quotation mark consistency:
-                                // false : do nothing (default)
-                                // true : ensure whatever is used is consistent
-                                // "single" : require single quotes
-                                // "double" : require double quotes
-    "undef" : true, // true: Require all non-global variables to be declared (prevents global leaks)
-    "unused" : true, // true: Require all defined variables be used
-    "strict" : true, // true: Requires all functions run in ES5 Strict Mode
-    "trailing" : false, // true: Prohibit trailing whitespaces
-    "maxparams" : false, // {int} Max number of formal params allowed per function
-    "maxdepth" : false, // {int} Max depth of nested blocks (within functions)
-    "maxstatements" : false, // {int} Max number statements per function
-    "maxcomplexity" : false, // {int} Max cyclomatic complexity per function
-    "maxlen" : false, // {int} Max number of characters per line
-
-    // Relaxing
-    "asi" : false, // true: Tolerate Automatic Semicolon Insertion (no semicolons)
-    "boss" : false, // true: Tolerate assignments where comparisons would be expected
-    "debug" : false, // true: Allow debugger statements e.g. browser breakpoints.
-    "eqnull" : false, // true: Tolerate use of `== null`
-    "es5" : false, // true: Allow ES5 syntax (ex: getters and setters)
-    "esnext" : false, // true: Allow ES.next (ES6) syntax (ex: `const`)
-    "moz" : false, // true: Allow Mozilla specific syntax (extends and overrides esnext features)
-                                 // (ex: `for each`, multiple try/catch, function expression…)
-    "evil" : false, // true: Tolerate use of `eval` and `new Function()`
-    "expr" : false, // true: Tolerate `ExpressionStatement` as Programs
-    "funcscope" : false, // true: Tolerate defining variables inside control statements"
-    "globalstrict" : false, // true: Allow global "use strict" (also enables 'strict')
-    "iterator" : false, // true: Tolerate using the `__iterator__` property
-    "lastsemic" : false, // true: Tolerate omitting a semicolon for the last statement of a 1-line block
-    "laxbreak" : false, // true: Tolerate possibly unsafe line breakings
-    "laxcomma" : false, // true: Tolerate comma-first style coding
-    "loopfunc" : false, // true: Tolerate functions being defined in loops
-    "multistr" : false, // true: Tolerate multi-line strings
-    "proto" : false, // true: Tolerate using the `__proto__` property
-    "scripturl" : false, // true: Tolerate script-targeted URLs
-    "smarttabs" : false, // true: Tolerate mixed tabs/spaces when used for alignment
-    "shadow" : false, // true: Allows re-define variables later in code e.g. `var x=1; x=2;`
-    "sub" : false, // true: Tolerate using `[]` notation when it can still be expressed in dot notation
-    "supernew" : false, // true: Tolerate `new function () { ... };` and `new Object;`
-    "validthis" : false, // true: Tolerate using this in a non-constructor function
-
-    // Environments
-    "browser" : true, // Web Browser (window, document, etc)
-    "couch" : false, // CouchDB
-    "devel" : true, // Development/debugging (alert, confirm, etc)
-    "dojo" : false, // Dojo Toolkit
-    "jquery" : true, // jQuery
-    "mootools" : false, // MooTools
-    "node" : true, // Node.js
-    "nonstandard" : false, // Widely adopted globals (escape, unescape, etc)
-    "prototypejs" : false, // Prototype and Scriptaculous
-    "rhino" : false, // Rhino
-    "worker" : false, // Web Workers
-    "wsh" : false, // Windows Scripting Host
-    "yui" : false, // Yahoo User Interface
-
-    // Legacy
-    "nomen" : false, // true: Prohibit dangling `_` in variables
-    "onevar" : false, // true: Allow only one `var` statement per function
-    "passfail" : false, // true: Stop on first error
-    "white" : false, // true: Check against strict whitespace and indentation rules
-
-    // Custom Globals
-    "globals" : {} // additional predefined global variables
-}