Skip to content

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

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

import type {GuildID, UserID} from '@app/api/BrandedTypes';
import type {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import type {Guild} from '@app/api/models/Guild';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {FriendSourceFlags, GroupDmAddPermissionFlags, RelationshipTypes} from '@fluxer/constants/src/UserConstants';
import {MissingAccessError} from '@fluxer/errors/src/domains/core/MissingAccessError';
import {FriendRequestBlockedError} from '@fluxer/errors/src/domains/user/FriendRequestBlockedError';

type UserPermissionRepository = Pick<UserRepository, 'findSettings' | 'listRelationships' | 'getRelationship'>;
type GuildPermissionRepository = Pick<GuildRepository, 'listUserGuilds'>;

export class UserPermissionUtils {
	constructor(
		private userRepository: UserPermissionRepository,
		private guildRepository: GuildPermissionRepository,
	) {}

	async validateFriendSourcePermissions({userId, targetId}: {userId: UserID; targetId: UserID}): Promise<void> {
		const targetSettings = await this.userRepository.findSettings(targetId);
		if (!targetSettings) return;
		const friendSourceFlags = targetSettings.friendSourceFlags;
		if ((friendSourceFlags & FriendSourceFlags.NO_RELATION) === FriendSourceFlags.NO_RELATION) {
			return;
		}
		if ((friendSourceFlags & FriendSourceFlags.MUTUAL_FRIENDS) === FriendSourceFlags.MUTUAL_FRIENDS) {
			const hasMutualFriends = await this.checkMutualFriends({userId, targetId});
			if (hasMutualFriends) {
				return;
			}
		}
		if ((friendSourceFlags & FriendSourceFlags.MUTUAL_GUILDS) === FriendSourceFlags.MUTUAL_GUILDS) {
			const hasMutualGuilds = await this.checkMutualGuildsAsync({userId, targetId});
			if (hasMutualGuilds) {
				return;
			}
		}
		throw new FriendRequestBlockedError();
	}

	async checkGroupDmAddPermission({userId, targetId}: {userId: UserID; targetId: UserID}): Promise<boolean> {
		const targetSettings = await this.userRepository.findSettings(targetId);
		if (!targetSettings) return true;
		const groupDmAddPermissionFlags = targetSettings.groupDmAddPermissionFlags;
		if ((groupDmAddPermissionFlags & GroupDmAddPermissionFlags.NOBODY) === GroupDmAddPermissionFlags.NOBODY) {
			return false;
		}
		if ((groupDmAddPermissionFlags & GroupDmAddPermissionFlags.EVERYONE) === GroupDmAddPermissionFlags.EVERYONE) {
			return true;
		}
		if (
			(groupDmAddPermissionFlags & GroupDmAddPermissionFlags.FRIENDS_ONLY) ===
			GroupDmAddPermissionFlags.FRIENDS_ONLY
		) {
			const friendship = await this.userRepository.getRelationship(targetId, userId, RelationshipTypes.FRIEND);
			return Boolean(friendship);
		}
		const friendship = await this.userRepository.getRelationship(targetId, userId, RelationshipTypes.FRIEND);
		if (friendship) return true;
		if (
			(groupDmAddPermissionFlags & GroupDmAddPermissionFlags.FRIENDS_OF_FRIENDS) ===
			GroupDmAddPermissionFlags.FRIENDS_OF_FRIENDS
		) {
			if (await this.checkMutualFriends({userId, targetId})) return true;
		}
		if (
			(groupDmAddPermissionFlags & GroupDmAddPermissionFlags.GUILD_MEMBERS) ===
			GroupDmAddPermissionFlags.GUILD_MEMBERS
		) {
			if (await this.checkMutualGuildsAsync({userId, targetId})) return true;
		}
		return false;
	}

	async validateGroupDmAddPermissions({userId, targetId}: {userId: UserID; targetId: UserID}): Promise<void> {
		const allowed = await this.checkGroupDmAddPermission({userId, targetId});
		if (!allowed) {
			throw new MissingAccessError();
		}
	}

	private async checkMutualFriends({userId, targetId}: {userId: UserID; targetId: UserID}): Promise<boolean> {
		const userFriends = await this.userRepository.listRelationships(userId);
		const targetFriends = await this.userRepository.listRelationships(targetId);
		const userFriendIds = new Set(
			userFriends.filter((rel) => rel.type === RelationshipTypes.FRIEND).map((rel) => rel.targetUserId.toString()),
		);
		const targetFriendIds = targetFriends
			.filter((rel) => rel.type === RelationshipTypes.FRIEND)
			.map((rel) => rel.targetUserId.toString());
		return targetFriendIds.some((friendId) => userFriendIds.has(friendId));
	}

	private async fetchGuildsForUsers({userId, targetId}: {userId: UserID; targetId: UserID}): Promise<{
		userGuilds: Array<Guild>;
		targetGuilds: Array<Guild>;
	}> {
		const [userGuilds, targetGuilds] = await Promise.all([
			this.guildRepository.listUserGuilds(userId),
			this.guildRepository.listUserGuilds(targetId),
		]);
		return {
			userGuilds,
			targetGuilds,
		};
	}

	private async fetchGuildIdsForUsers({userId, targetId}: {userId: UserID; targetId: UserID}): Promise<{
		userGuildIds: Array<GuildID>;
		targetGuildIds: Array<GuildID>;
	}> {
		const {userGuilds, targetGuilds} = await this.fetchGuildsForUsers({userId, targetId});
		return {
			userGuildIds: userGuilds.map((g) => g.id),
			targetGuildIds: targetGuilds.map((g) => g.id),
		};
	}

	async checkMutualGuildsAsync({userId, targetId}: {userId: UserID; targetId: UserID}): Promise<boolean> {
		const {userGuildIds, targetGuildIds} = await this.fetchGuildIdsForUsers({userId, targetId});
		return this.checkMutualGuilds(userGuildIds, targetGuildIds);
	}

	private checkMutualGuilds(userGuildIds: Array<GuildID>, targetGuildIds: Array<GuildID>): boolean {
		const userGuildIdSet = new Set(userGuildIds.map((id) => id.toString()));
		return targetGuildIds.some((id) => userGuildIdSet.has(id.toString()));
	}
}