Replace owner/moderator finds by aggregation

Author: matheusbsilva137

apps/meteor/server/lib/findUsersOfRoomByHighestRole.ts

@@ -1,66 +1,18 @@
-import type { IUserWithRoleInfo, ISubscription, IUser } from '@rocket.chat/core-typings';
+import type { IUserWithRoleInfo, IUser, IRoom, UserStatus } from '@rocket.chat/core-typings';
 import { Users, Subscriptions } from '@rocket.chat/models';
-import type { FilterOperators, FindOptions } from 'mongodb';
+import type { Filter, FilterOperators, FindOptions } from 'mongodb';
 
 import { settings } from '../../app/settings/server';
 
 type FindUsersParam = {
 	rid: string;
-	status?: FilterOperators<string>;
+	status?: FilterOperators<UserStatus>;
 	skip?: number;
 	limit?: number;
 	filter?: string;
 	sort?: Record<string, any>;
 };
 
-async function findUsersWithRolesOfRoom(
-	{ rid, status, limit = 0, filter = '' }: FindUsersParam,
-	options: FindOptions<IUser>,
-): Promise<{ members: IUserWithRoleInfo[]; totalCount: number; allMembersIds: string[] }> {
-	// Sort roles in descending order so that owners are listed before moderators
-	// This could possibly cause issues with custom roles, but that's intended to improve performance
-	const highestRolesMembersSubscriptions = await Subscriptions.findByRoomIdAndRoles(rid, ['owner', 'moderator'], {
-		projection: { 'u._id': 1, 'roles': 1 },
-		sort: { roles: -1 },
-	}).toArray();
-
-	const searchFields = settings.get<string>('Accounts_SearchFields').trim().split(',');
-
-	const totalCount = highestRolesMembersSubscriptions.length;
-	const allMembersIds = highestRolesMembersSubscriptions.map((s: ISubscription) => s.u?._id);
-	const highestRolesMembersIdsToFind = allMembersIds.slice(0, limit);
-
-	const { cursor } = Users.findPaginatedActiveUsersByIds(filter, searchFields, highestRolesMembersIdsToFind, options, [
-		{
-			__rooms: rid,
-			...(status && { status }),
-		},
-	]);
-	const highestRolesMembers = await cursor.toArray();
-
-	// maps for efficient lookup of highest roles and sort order
-	const ordering: Record<string, number> = {};
-	const highestRoleById: Record<string, string> = {};
-
-	const limitedHighestRolesMembersSubs = highestRolesMembersSubscriptions.slice(0, limit);
-	limitedHighestRolesMembersSubs.forEach((sub, index) => {
-		ordering[sub.u._id] = index;
-		highestRoleById[sub.u._id] = sub.roles?.includes('owner') ? 'owner' : 'moderator';
-	});
-
-	highestRolesMembers.sort((a, b) => ordering[a._id] - ordering[b._id]);
-	const membersWithHighestRoles = highestRolesMembers.map(
-		(member): IUserWithRoleInfo => ({
-			...member,
-			highestRole: {
-				role: highestRoleById[member._id],
-				level: highestRoleById[member._id] === 'owner' ? 0 : 1,
-			},
-		}),
-	);
-	return { members: membersWithHighestRoles, totalCount, allMembersIds };
-}
-
 export async function findUsersOfRoomByHighestRole({
 	rid,
 	status,
@@ -85,22 +37,25 @@ export async function findUsersOfRoomByHighestRole({
 		},
 		limit,
 	};
-	const extraQuery = {
+	const extraQuery: Filter<IUser & { __rooms: IRoom['_id'][] }> = {
 		__rooms: rid,
 		...(status && { status }),
 	};
 	const searchFields = settings.get<string>('Accounts_SearchFields').trim().split(',');
 
-	// Find highest roles members (owners and moderator)
+	// Find highest roles members (owners and moderators)
+	const result = await Subscriptions.findPaginatedActiveHighestRoleUsers(filter, rid, searchFields, options, extraQuery);
 	const {
-		members: highestRolesMembers,
-		totalCount: totalMembersWithRoles,
-		allMembersIds: highestRolesMembersIds,
-	} = await findUsersWithRolesOfRoom({ rid, status, limit, filter }, options);
+		members: highestRolesMembers = [],
+		totalCount: totalMembersWithRoles = { total: 0 },
+		ids = { allMembersIds: [] },
+	} = result[0] || {};
+	const { total: totalMembersWithRolesCount } = totalMembersWithRoles;
+	const { allMembersIds: highestRolesMembersIds } = ids;
 
 	if (limit <= highestRolesMembers.length) {
 		const totalMembersCount = await Users.countActiveUsersExcept(filter, highestRolesMembersIds, searchFields, [extraQuery]);
-		return { members: highestRolesMembers, total: totalMembersWithRoles + totalMembersCount };
+		return { members: highestRolesMembers, total: totalMembersWithRolesCount + totalMembersCount };
 	}
 	if (options.limit) {
 		options.limit -= highestRolesMembers.length;
@@ -122,5 +77,5 @@ export async function findUsersOfRoomByHighestRole({
 	);
 
 	const allMembers = highestRolesMembers.concat(membersWithHighestRoles);
-	return { members: allMembers, total: totalMembersWithRoles + totalMembersCount };
+	return { members: allMembers, total: totalMembersWithRolesCount + totalMembersCount };
 }

apps/meteor/server/models/raw/Subscriptions.ts

@@ -1,4 +1,13 @@
-import type { IRole, IRoom, ISubscription, IUser, RocketChatRecordDeleted, RoomType, SpotlightUser } from '@rocket.chat/core-typings';
+import type {
+	IRole,
+	IRoom,
+	ISubscription,
+	IUser,
+	IUserWithRoleInfo,
+	RocketChatRecordDeleted,
+	RoomType,
+	SpotlightUser,
+} from '@rocket.chat/core-typings';
 import type { ISubscriptionsModel } from '@rocket.chat/model-typings';
 import { Rooms, Users } from '@rocket.chat/models';
 import { escapeRegExp } from '@rocket.chat/string-helpers';
@@ -450,6 +459,96 @@ export class SubscriptionsRaw extends BaseRaw<ISubscription> implements ISubscri
 			.toArray();
 	}
 
+	async findPaginatedActiveHighestRoleUsers(
+		searchTerm: string,
+		rid: IRoom['_id'],
+		searchFields: string[],
+		options: FindOptions<IUser> = {},
+		extraQuery?: Filter<IUser>,
+		{ startsWith = false, endsWith = false }: { startsWith?: string | false; endsWith?: string | false } = {},
+	): Promise<{ members: IUserWithRoleInfo[]; totalCount: { total: number }; ids: { allMembersIds: string[] } }[]> {
+		const termRegex = new RegExp((startsWith ? '^' : '') + escapeRegExp(searchTerm) + (endsWith ? '$' : ''), 'i');
+		const orStatement = (searchFields || []).map((el) => ({ [el.trim()]: termRegex })) as { [x: string]: RegExp }[];
+
+		const limit =
+			options.limit !== 0
+				? [
+						{
+							$limit: options.limit,
+						},
+				  ]
+				: [];
+
+		return this.col
+			.aggregate<{ members: IUserWithRoleInfo[]; totalCount: { total: number }; ids: { allMembersIds: string[] } }>(
+				[
+					{
+						$match: {
+							rid,
+							roles: { $in: ['owner', 'moderator'] },
+						},
+					},
+					{
+						$lookup: {
+							from: 'users',
+							as: 'user',
+							let: { id: '$u._id' },
+							pipeline: [
+								{
+									$match: {
+										$expr: { $eq: ['$_id', '$$id'] },
+										username: { $exists: true },
+										active: true,
+										...(searchTerm && orStatement.length > 0 && { $or: orStatement }),
+										...extraQuery,
+									},
+								},
+								{ $project: options.projection },
+							],
+						},
+					},
+					{
+						$unwind: {
+							path: '$user',
+						},
+					},
+					{
+						$addFields: {
+							'user.highestRole': {
+								$cond: [{ $in: ['owner', '$roles'] }, { role: 'owner', level: 0 }, { role: 'moderator', level: 1 }],
+							},
+						},
+					},
+					{
+						$replaceRoot: { newRoot: '$user' },
+					},
+					{
+						$facet: {
+							members: [
+								{
+									$sort: {
+										'highestRole.level': 1,
+										...(options.sort as object),
+									},
+								},
+								...limit,
+							],
+							ids: [{ $group: { _id: null, allMembersIds: { $push: '$_id' } } }],
+							totalCount: [{ $count: 'total' }],
+						},
+					},
+					{
+						$unwind: { path: '$totalCount' },
+					},
+					{
+						$unwind: { path: '$ids' },
+					},
+				],
+				{ allowDiskUse: true },
+			)
+			.toArray();
+	}
+
 	incUnreadForRoomIdExcludingUserIds(roomId: IRoom['_id'], userIds: IUser['_id'][], inc: number): Promise<UpdateResult | Document> {
 		if (inc == null) {
 			inc = 1;

packages/model-typings/src/models/ISubscriptionsModel.ts

@@ -1,4 +1,4 @@
-import type { ISubscription, IRole, IUser, IRoom, RoomType, SpotlightUser } from '@rocket.chat/core-typings';
+import type { ISubscription, IRole, IUser, IRoom, RoomType, SpotlightUser, IUserWithRoleInfo } from '@rocket.chat/core-typings';
 import type { FindOptions, FindCursor, UpdateResult, DeleteResult, Document, AggregateOptions, Filter, InsertOneResult } from 'mongodb';
 
 import type { IBaseModel } from './IBaseModel';
@@ -76,6 +76,15 @@ export interface ISubscriptionsModel extends IBaseModel<ISubscription> {
 		options?: AggregateOptions,
 	): Promise<SpotlightUser[]>;
 
+	findPaginatedActiveHighestRoleUsers(
+		searchTerm: string,
+		rid: IRoom['_id'],
+		searchFields: string[],
+		options?: FindOptions<IUser>,
+		extraQuery?: Filter<IUser & { __rooms: IRoom['_id'][] }>,
+		{ startsWith = false, endsWith = false }?: { startsWith?: string | false; endsWith?: string | false },
+	): Promise<{ members: IUserWithRoleInfo[]; totalCount: { total: number }; ids: { allMembersIds: string[] } }[]>;
+
 	incUnreadForRoomIdExcludingUserIds(roomId: IRoom['_id'], userIds: IUser['_id'][], inc: number): Promise<UpdateResult | Document>;
 
 	setAlertForRoomIdExcludingUserId(roomId: IRoom['_id'], userId: IUser['_id']): Promise<UpdateResult | Document>;