Skip to content

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

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

import type {GuildID, InviteCode, RoleID, UserID} from '@app/api/BrandedTypes';
import type {ChannelService} from '@app/api/channel/services/ChannelService';
import {SYSTEM_USER_ID} from '@app/api/constants/Core';
import type {GuildAuditLogService} from '@app/api/guild/GuildAuditLogService';
import type {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import {GuildMemberAuditService} from '@app/api/guild/services/member/GuildMemberAuditService';
import {GuildMemberEventService} from '@app/api/guild/services/member/GuildMemberEventService';
import {GuildMemberOperationsService} from '@app/api/guild/services/member/GuildMemberOperationsService';
import {GuildMemberRoleService} from '@app/api/guild/services/member/GuildMemberRoleService';
import {
	type GuildMemberRoleWriteLocks,
	withGuildMemberRoleWriteLock,
} from '@app/api/guild/services/member/GuildMemberRoleWriteLock';
import {GuildMemberSearchIndexService} from '@app/api/guild/services/member/GuildMemberSearchIndexService';
import {GuildMemberValidationService} from '@app/api/guild/services/member/GuildMemberValidationService';
import type {EntityAssetService} from '@app/api/infrastructure/EntityAssetService';
import type {IGatewayService} from '@app/api/infrastructure/IGatewayService';
import type {UserCacheService} from '@app/api/infrastructure/UserCacheService';
import type {LimitConfigService} from '@app/api/limits/LimitConfigService';
import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
import type {Guild} from '@app/api/models/Guild';
import type {GuildMember} from '@app/api/models/GuildMember';
import {recordOperatorPassLabsDeparture} from '@app/api/operator_pass/OperatorPassLabsRole';
import type {TierContext} from '@app/api/user/AccountTier';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {AuditLogActionType} from '@fluxer/constants/src/AuditLogActionType';
import type {JoinSourceType} from '@fluxer/constants/src/GuildConstants';
import {UnknownGuildMemberError} from '@fluxer/errors/src/domains/guild/UnknownGuildMemberError';
import type {GuildMemberResponse} from '@fluxer/schema/src/domains/guild/GuildMemberSchemas';
import type {GuildMemberUpdateRequest} from '@fluxer/schema/src/domains/guild/GuildRequestSchemas';
import type {IRateLimitService} from '@pkgs/rate_limit/src/IRateLimitService';

export class GuildMemberService {
	private async applyRoleChange(params: {
		actorId: UserID;
		targetId: UserID;
		guildId: GuildID;
		roleId: RoleID;
		requestCache: RequestCache;
		auditLogReason?: string | null;
		mutate: () => Promise<void>;
	}): Promise<void> {
		const {actorId: userId, targetId, guildId, roleId, requestCache, auditLogReason, mutate} = params;
		const targetMember = await this.guildRepository.getMember(guildId, targetId);
		if (!targetMember) throw new UnknownGuildMemberError();
		const previousSnapshot = this.auditService.serializeMemberForAudit(targetMember);
		const role = await this.guildRepository.getRole(roleId, guildId);
		await mutate();
		const updatedMember = await this.guildRepository.getMember(guildId, targetId);
		if (updatedMember) {
			await this.eventService.dispatchGuildMemberUpdate({guildId, member: updatedMember, requestCache});
			await this.refreshMemberSearchIndex(updatedMember);
			await this.guildAuditLogService.record({
				guildId,
				userId,
				action: AuditLogActionType.MEMBER_ROLE_UPDATE,
				targetId: targetId,
				auditLogReason: auditLogReason ?? null,
				metadata: role ? {role_name: role.name} : undefined,
				changes: this.guildAuditLogService.computeChanges(
					previousSnapshot,
					this.auditService.serializeMemberForAudit(updatedMember),
				),
			});
		}
	}

	private async refreshMemberSearchIndex(member: GuildMember): Promise<void> {
		const user = await this.userRepository.findUnique(member.userId);
		if (!user) return;
		const guild = await this.guildRepository.findUnique(member.guildId);
		const options = this.getMemberSearchIndexOptions(guild);
		if (options) void this.searchIndexService.updateMember(member, user, options);
	}

	private readonly validationService: GuildMemberValidationService;
	private readonly auditService: GuildMemberAuditService;
	private readonly eventService: GuildMemberEventService;
	private readonly operationsService: GuildMemberOperationsService;
	private readonly roleService: GuildMemberRoleService;
	private readonly searchIndexService: GuildMemberSearchIndexService;
	private readonly userRepository: UserRepository;

	constructor(
		private readonly guildRepository: GuildRepository,
		channelService: ChannelService,
		userCacheService: UserCacheService,
		gatewayService: IGatewayService,
		entityAssetService: EntityAssetService,
		userRepository: UserRepository,
		rateLimitService: IRateLimitService,
		private readonly guildAuditLogService: GuildAuditLogService,
		limitConfigService: LimitConfigService,
		private readonly cacheService: GuildMemberRoleWriteLocks,
	) {
		this.userRepository = userRepository;
		this.validationService = new GuildMemberValidationService(guildRepository);
		this.auditService = new GuildMemberAuditService();
		this.eventService = new GuildMemberEventService(gatewayService, userCacheService);
		this.searchIndexService = new GuildMemberSearchIndexService();
		this.operationsService = new GuildMemberOperationsService(
			guildRepository,
			channelService,
			userCacheService,
			gatewayService,
			entityAssetService,
			userRepository,
			rateLimitService,
			this.validationService,
			this.guildAuditLogService,
			limitConfigService,
			this.searchIndexService,
			cacheService,
		);
		this.roleService = new GuildMemberRoleService(
			guildRepository,
			gatewayService,
			userRepository,
			this.validationService,
			cacheService,
		);
	}

	private getMemberSearchIndexOptions(guild: Guild | null | undefined) {
		if (!guild) {
			return null;
		}
		const includeDefault = guild.membersIndexedAt != null;
		return includeDefault ? {includeDefault} : null;
	}

	async getMembers(params: {
		userId: UserID;
		guildId: GuildID;
		limit?: number;
		after?: UserID;
	}): Promise<Array<GuildMemberResponse>> {
		return this.operationsService.getMembers(params);
	}

	async getMember(params: {
		userId: UserID;
		targetId: UserID;
		guildId: GuildID;
		requestCache: RequestCache;
	}): Promise<GuildMemberResponse> {
		return this.operationsService.getMember(params);
	}

	async updateMember(
		params: {
			userId: UserID;
			targetId: UserID;
			guildId: GuildID;
			data: GuildMemberUpdateRequest | Omit<GuildMemberUpdateRequest, 'roles'>;
			requestCache: RequestCache;
		},
		auditLogReason?: string | null,
	): Promise<GuildMemberResponse> {
		const {userId, targetId, guildId, data, requestCache} = params;
		const targetMember = await this.guildRepository.getMember(guildId, targetId);
		if (!targetMember) throw new UnknownGuildMemberError();
		const previousSnapshot = this.auditService.serializeMemberForAudit(targetMember);
		const result = await this.operationsService.updateMember({
			userId,
			targetId,
			guildId,
			data,
			requestCache,
			auditLogReason,
		});
		const updatedMember = await this.guildRepository.getMember(guildId, targetId);
		if (!updatedMember) throw new UnknownGuildMemberError();
		await this.eventService.dispatchGuildMemberUpdate({guildId, member: updatedMember, requestCache});
		await this.refreshMemberSearchIndex(updatedMember);
		await this.guildAuditLogService.record({
			guildId,
			userId,
			action: AuditLogActionType.MEMBER_UPDATE,
			targetId: targetId,
			auditLogReason:
				auditLogReason ??
				(data.communication_disabled_until !== undefined ? data.timeout_reason?.trim() || null : null),
			changes: this.guildAuditLogService.computeChanges(
				previousSnapshot,
				this.auditService.serializeMemberForAudit(updatedMember),
			),
		});
		return result;
	}

	async addMemberRole(
		params: {
			userId: UserID;
			targetId: UserID;
			guildId: GuildID;
			roleId: RoleID;
			requestCache: RequestCache;
		},
		auditLogReason?: string | null,
	): Promise<void> {
		await this.applyRoleChange({
			...params,
			actorId: params.userId,
			auditLogReason: auditLogReason,
			mutate: () => this.roleService.addMemberRole(params),
		});
	}

	async systemAddMemberRole(params: {
		targetId: UserID;
		guildId: GuildID;
		roleId: RoleID;
		initiatorId: UserID;
		requestCache: RequestCache;
	}): Promise<void> {
		await this.applyRoleChange({
			...params,
			actorId: params.initiatorId,
			auditLogReason: null,
			mutate: () => this.roleService.systemAddMemberRole(params),
		});
	}

	async systemSyncManagedRoles(params: {
		targetId: UserID;
		guildId: GuildID;
		managedRoleIds: ReadonlySet<RoleID>;
		grantedRoleIds: ReadonlySet<RoleID>;
		requestCache: RequestCache;
	}): Promise<void> {
		const {targetId, guildId, managedRoleIds, grantedRoleIds, requestCache} = params;
		const existingRoleIds = new Set((await this.guildRepository.listRoles(guildId)).map((role) => role.id));
		const member = await withGuildMemberRoleWriteLock(this.cacheService, guildId, targetId, async () => {
			const currentMember = await this.guildRepository.getMember(guildId, targetId);
			if (!currentMember) return null;
			const nextRoleIds = new Set([...currentMember.roleIds].filter((roleId) => !managedRoleIds.has(roleId)));
			for (const roleId of grantedRoleIds) {
				if (managedRoleIds.has(roleId) && existingRoleIds.has(roleId)) nextRoleIds.add(roleId);
			}
			if (
				nextRoleIds.size === currentMember.roleIds.size &&
				[...nextRoleIds].every((roleId) => currentMember.roleIds.has(roleId))
			) {
				return null;
			}
			const previousRow = currentMember.toRow();
			await this.guildRepository.upsertMember({...previousRow, role_ids: nextRoleIds}, previousRow);
			return currentMember;
		});
		if (!member) return;
		const previousSnapshot = this.auditService.serializeMemberForAudit(member);
		const updatedMember = await this.guildRepository.getMember(guildId, targetId);
		if (!updatedMember) return;
		await this.eventService.dispatchGuildMemberUpdate({guildId, member: updatedMember, requestCache});
		await this.refreshMemberSearchIndex(updatedMember);
		await this.guildAuditLogService.record({
			guildId,
			userId: SYSTEM_USER_ID,
			action: AuditLogActionType.MEMBER_ROLE_UPDATE,
			targetId,
			auditLogReason: null,
			changes: this.guildAuditLogService.computeChanges(
				previousSnapshot,
				this.auditService.serializeMemberForAudit(updatedMember),
			),
		});
	}

	async systemRemoveMemberRole(params: {
		targetId: UserID;
		guildId: GuildID;
		roleId: RoleID;
		initiatorId: UserID;
		requestCache: RequestCache;
	}): Promise<void> {
		await this.applyRoleChange({
			...params,
			actorId: params.initiatorId,
			auditLogReason: null,
			mutate: () => this.roleService.systemRemoveMemberRole(params),
		});
	}

	async removeMemberRole(
		params: {
			userId: UserID;
			targetId: UserID;
			guildId: GuildID;
			roleId: RoleID;
			requestCache: RequestCache;
		},
		auditLogReason?: string | null,
	): Promise<void> {
		await this.applyRoleChange({
			...params,
			actorId: params.userId,
			auditLogReason: auditLogReason,
			mutate: () => this.roleService.removeMemberRole(params),
		});
	}

	async removeMember(
		params: {
			userId: UserID;
			targetId: UserID;
			guildId: GuildID;
		},
		auditLogReason?: string | null,
	): Promise<void> {
		const {userId, targetId, guildId} = params;
		const targetMember = await this.guildRepository.getMember(guildId, targetId);
		if (!targetMember) throw new UnknownGuildMemberError();
		await this.operationsService.removeMember(params);
		await recordOperatorPassLabsDeparture(guildId, targetId, 'kicked');
		await this.finishMemberKick({guildId, targetId, actorId: userId}, auditLogReason ?? null);
	}

	async removeMemberAsSystem(params: {targetId: UserID; guildId: GuildID}): Promise<void> {
		await this.operationsService.removeMemberAsSystem(params);
		await recordOperatorPassLabsDeparture(params.guildId, params.targetId, 'kicked');
		await this.finishMemberKick({...params, actorId: SYSTEM_USER_ID}, null);
	}

	private async finishMemberKick(
		{guildId, targetId, actorId}: {guildId: GuildID; targetId: UserID; actorId: UserID},
		auditLogReason: string | null,
	): Promise<void> {
		const guild = await this.guildRepository.findUnique(guildId);
		const searchIndexOptions = this.getMemberSearchIndexOptions(guild);
		if (searchIndexOptions) {
			void this.searchIndexService.deleteMember(guildId, targetId, searchIndexOptions);
		}
		await this.eventService.dispatchGuildMemberRemove({guildId, userId: targetId});
		await this.guildAuditLogService.record({
			guildId,
			userId: actorId,
			action: AuditLogActionType.MEMBER_KICK,
			changes: null,
			targetId: targetId,
			auditLogReason,
		});
	}

	async addUserToGuild(params: {
		userId: UserID;
		guildId: GuildID;
		sendJoinMessage?: boolean;
		skipGuildLimitCheck?: boolean;
		skipBanCheck?: boolean;
		ip?: string | null;
		skipAccountLimitCheck?: boolean;
		isTemporary?: boolean;
		joinSourceType?: JoinSourceType;
		sourceInviteCode?: InviteCode;
		inviterId?: UserID;
		requestCache: RequestCache;
		initiatorId?: UserID;
		tierContext?: TierContext;
		mentionsOnlyNotifications?: boolean;
	}): Promise<GuildMember> {
		return this.operationsService.addUserToGuild(params, this.eventService);
	}

	async leaveGuild(
		params: {
			userId: UserID;
			guildId: GuildID;
		},
		_auditLogReason?: string | null,
	): Promise<void> {
		const {userId, guildId} = params;
		const member = await this.guildRepository.getMember(guildId, userId);
		if (!member) throw new UnknownGuildMemberError();
		await this.operationsService.leaveGuild(params);
		await recordOperatorPassLabsDeparture(guildId, userId, 'left');
		const guild = await this.guildRepository.findUnique(guildId);
		const searchIndexOptions = this.getMemberSearchIndexOptions(guild);
		if (searchIndexOptions) {
			void this.searchIndexService.deleteMember(guildId, userId, searchIndexOptions);
		}
		await this.eventService.dispatchGuildMemberRemove({guildId, userId});
	}
}