A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// 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,
});
},
);
}