Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
5.9 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {createGuildID, createUserID} from '@app/api/BrandedTypes';
import {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import {LoginRequired} from '@app/api/middleware/AuthMiddleware';
import {RateLimitMiddleware} from '@app/api/middleware/RateLimitMiddleware';
import {OpenAPI} from '@app/api/middleware/ResponseTypeMiddleware';
import {RateLimitConfigs} from '@app/api/RateLimitConfig';
import {getGuildMemberSearchService} from '@app/api/SearchFactory';
import {channelNeedsReindexing} from '@app/api/search/ChannelIndexingUtils';
import type {HonoApp} from '@app/api/types/HonoEnv';
import {isHiddenPartial} from '@app/api/user/ProfileVisibility';
import {Validator} from '@app/api/Validator';
import {Permissions} from '@fluxer/constants/src/ChannelConstants';
import {GUILD_MEMBERS_REINDEX_AFTER_TIMESTAMP} from '@fluxer/constants/src/GuildConstants';
import {MissingPermissionsError} from '@fluxer/errors/src/domains/core/MissingPermissionsError';
import type {SearchableGuildMember} from '@fluxer/schema/src/contracts/search/SearchDocumentTypes';
import {GuildIdParam} from '@fluxer/schema/src/domains/common/CommonParamSchemas';
import {
	GuildMemberSearchRequest,
	GuildMemberSearchResponse,
	type GuildMemberSearchResponse as GuildMemberSearchResponseBody,
	type GuildMemberSearchResult,
} from '@fluxer/schema/src/domains/guild/GuildMemberSearchSchemas';
import type {UserPartialResponse} from '@fluxer/schema/src/domains/user/UserResponseSchemas';

const MEMBERS_PAGE_PERMISSIONS =
	Permissions.MANAGE_GUILD |
	Permissions.MANAGE_ROLES |
	Permissions.MANAGE_NICKNAMES |
	Permissions.BAN_MEMBERS |
	Permissions.MODERATE_MEMBERS |
	Permissions.KICK_MEMBERS;
const guildRepository = new GuildRepository();

function createEmptySearchResponse(guildId: string, indexing: boolean): GuildMemberSearchResponseBody {
	return {
		guild_id: guildId,
		members: [],
		page_result_count: 0,
		total_result_count: 0,
		indexing,
	};
}

function mapSearchableMember(
	hit: SearchableGuildMember,
	partial: UserPartialResponse | undefined,
): GuildMemberSearchResult {
	const hidden = partial != null && isHiddenPartial(partial);
	return {
		id: hit.id,
		guild_id: hit.guildId,
		user_id: hit.userId,
		username: partial?.username ?? hit.username,
		discriminator: partial?.discriminator ?? hit.discriminator,
		global_name: partial ? partial.global_name : hit.globalName,
		nickname: hidden ? null : hit.nickname,
		role_ids: hit.roleIds,
		joined_at: hit.joinedAt,
		supplemental: {
			join_source_type: hit.joinSourceType,
			source_invite_code: hit.sourceInviteCode,
			inviter_id: hit.inviterId,
		},
		is_bot: hit.isBot,
	};
}

export function GuildMemberSearchController(app: HonoApp) {
	app.post(
		'/guilds/:guild_id/members-search',
		RateLimitMiddleware(RateLimitConfigs.GUILD_MEMBERS),
		LoginRequired,
		Validator('param', GuildIdParam),
		Validator('json', GuildMemberSearchRequest),
		OpenAPI({
			operationId: 'search_guild_members',
			summary: 'Search guild members',
			responseSchema: GuildMemberSearchResponse,
			statusCode: 200,
			security: ['botToken', 'bearerToken', 'sessionToken'],
			tags: ['Guilds'],
			description: 'Search and filter guild members with pagination support.',
		}),
		async (ctx) => {
			const userId = ctx.get('user').id;
			const guildId = createGuildID(ctx.req.valid('param').guild_id);
			const guildIdString = guildId.toString();
			const body = ctx.req.valid('json');
			const {getMyPermissions, enforceGuildMfa} = await ctx
				.get('guildService')
				.getGuildAuthenticated({userId, guildId});
			const permissions = await getMyPermissions();
			if ((permissions & MEMBERS_PAGE_PERMISSIONS) === 0n) {
				throw new MissingPermissionsError();
			}
			enforceGuildMfa(permissions & MEMBERS_PAGE_PERMISSIONS);
			const canViewInvites = (permissions & Permissions.MANAGE_GUILD) !== 0n;
			const guild = await guildRepository.findUnique(guildId);
			if (!guild) {
				return ctx.json(createEmptySearchResponse(guildIdString, false));
			}
			const searchService = getGuildMemberSearchService();
			if (!searchService?.isAvailable()) {
				return ctx.json(createEmptySearchResponse(guildIdString, false));
			}
			const needsIndexing = channelNeedsReindexing(guild.membersIndexedAt, GUILD_MEMBERS_REINDEX_AFTER_TIMESTAMP);
			if (needsIndexing) {
				const workerService = ctx.get('workerService');
				await workerService.addJob(
					'indexGuildMembers',
					{
						guildId: guildIdString,
					},
					{jobKey: `index-guild-members-${guildId}-lazy`, maxAttempts: 3},
				);
				return ctx.json(createEmptySearchResponse(guildIdString, true));
			}
			const query = body.query?.trim() ?? '';
			const limit = body.limit ?? 25;
			const offset = body.offset ?? 0;
			const results = await searchService.searchMembers(
				query,
				{
					guildId: guildIdString,
					roleIds: body.role_ids,
					joinedAtGte: body.joined_at_gte,
					joinedAtLte: body.joined_at_lte,
					joinSourceType: canViewInvites ? body.join_source_type : undefined,
					sourceInviteCode: canViewInvites ? body.source_invite_code : undefined,
					userCreatedAtGte: body.user_created_at_gte,
					userCreatedAtLte: body.user_created_at_lte,
					isBot: body.is_bot,
					sortBy: body.sort_by,
					sortOrder: body.sort_order,
				},
				{limit, offset},
			);
			const userIds = results.hits.map((hit) => createUserID(BigInt(hit.userId)));
			const partials = await ctx.get('userCacheService').getUserPartialResponses(userIds, ctx.get('requestCache'));
			const members = results.hits.map((hit, index) => {
				const member = mapSearchableMember(hit, partials.get(userIds[index]));
				if (!canViewInvites) {
					member.supplemental = {
						join_source_type: null,
						source_invite_code: null,
						inviter_id: null,
					};
				}
				return member;
			});
			return ctx.json({
				guild_id: guildIdString,
				members,
				page_result_count: members.length,
				total_result_count: results.total,
				indexing: false,
			});
		},
	);
}