Skip to content

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

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

import type {GuildID, UserID} from '@app/api/BrandedTypes';
import {Config} from '@app/api/Config';
import type {ConnectionRepository} from '@app/api/connection/ConnectionRepository';
import type {UserConnectionRow} from '@app/api/database/types/ConnectionTypes';
import type {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import type {GuildService} from '@app/api/guild/services/GuildService';
import type {DiscriminatorService} from '@app/api/infrastructure/DiscriminatorService';
import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
import type {GuildMember} from '@app/api/models/GuildMember';
import type {User} from '@app/api/models/User';
import {isProfileHidden} from '@app/api/user/ProfileVisibility';
import {applyPremiumBadgeMasking} from '@app/api/user/profile_badges/PremiumBadgeMasking';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {isUsernameTaken} from '@app/api/user/UniqueUsernames';
import {hasFixedDiscriminator} from '@app/api/user/UserTag';
import {ChannelTypes} from '@fluxer/constants/src/ChannelConstants';
import {
	ProfileFieldPrivacyFlags,
	ProfilePrivacyLevels,
	RelationshipTypes,
	SMALL_GUILD_MEMBER_THRESHOLD,
	type UserPremiumType,
} from '@fluxer/constants/src/UserConstants';
import {MissingAccessError} from '@fluxer/errors/src/domains/core/MissingAccessError';
import type {GuildMemberResponse} from '@fluxer/schema/src/domains/guild/GuildMemberSchemas';

interface ProfileFieldPrivacyContext {
	isOwner: boolean;
	isFriend: boolean;
	hasMutualGuild: boolean;
}

interface UserAccountLookupServiceDeps {
	userAccountRepository: UserRepository;

	guildRepository: GuildRepository;
	guildService: GuildService;
	discriminatorService: DiscriminatorService;
	connectionRepository: ConnectionRepository;
}

export class UserAccountLookupService {
	constructor(private readonly deps: UserAccountLookupServiceDeps) {}

	async findUnique(userId: UserID): Promise<User | null> {
		return await this.deps.userAccountRepository.findUnique(userId);
	}

	async getUserProfile(params: {
		userId: UserID;
		targetId: UserID;
		guildId?: GuildID;
		withMutualFriends?: boolean;
		withMutualGuilds?: boolean;
		requestCache: RequestCache;
	}): Promise<{
		user: User;
		guildMember?: GuildMemberResponse | null;
		guildMemberDomain?: GuildMember | null;
		premiumType?: UserPremiumType;
		premiumSince?: Date;
		premiumLifetimeSequence?: number;
		mutualFriends?: Array<User>;
		mutualGuilds?: Array<{
			id: string;
			nick: string | null;
		}>;
		connections?: Array<UserConnectionRow>;
		timezoneVisible: boolean;
		restrictProfile: boolean;
	}> {
		const {userId, targetId, guildId, withMutualFriends, withMutualGuilds, requestCache} = params;
		const user = await this.deps.userAccountRepository.findUniqueAssert(targetId);
		if (userId !== targetId) {
			await this.validateProfileAccess(userId, targetId, user);
		}
		const restrictProfile = await this.shouldRestrictProfile(userId, targetId, user);
		const hiddenFromViewer = userId !== targetId && isProfileHidden(user);
		let guildMember: GuildMemberResponse | null = null;
		let guildMemberDomain: GuildMember | null = null;
		if (guildId != null) {
			const viewerMember = await this.deps.guildRepository.getMember(guildId, userId);
			if (viewerMember) {
				guildMemberDomain = await this.deps.guildRepository.getMember(guildId, targetId);
				if (guildMemberDomain) {
					guildMember = await this.deps.guildService.members.getMember({
						userId,
						targetId,
						guildId,
						requestCache,
					});
				}
			}
		}
		const {premiumType, premiumSince, premiumLifetimeSequence} = applyPremiumBadgeMasking(user, {
			premiumFlags: user.premiumFlags,
			hidden: user.hiddenProfileBadges,
			selfHosted: Config.instance.selfHosted,
			restricted: restrictProfile || hiddenFromViewer,
		});
		const profileFieldPrivacyContext = restrictProfile
			? null
			: await this.getProfileFieldPrivacyContext(userId, targetId);
		const timezoneVisible =
			!restrictProfile &&
			!hiddenFromViewer &&
			user.timezone != null &&
			profileFieldPrivacyContext != null &&
			this.canViewProfileField(user.timezonePrivacyFlags, profileFieldPrivacyContext);
		const [mutualFriends, mutualGuilds, connections] = await Promise.all([
			withMutualFriends && userId !== targetId ? this.getMutualFriends(userId, targetId) : undefined,
			withMutualGuilds && userId !== targetId ? this.getMutualGuilds(userId, targetId) : undefined,
			restrictProfile || profileFieldPrivacyContext == null
				? Promise.resolve([] as Array<UserConnectionRow>)
				: this.getVisibleConnections(targetId, profileFieldPrivacyContext),
		]);
		return {
			user,
			guildMember,
			guildMemberDomain,
			premiumType,
			premiumSince,
			premiumLifetimeSequence,
			mutualFriends,
			mutualGuilds,
			connections,
			timezoneVisible,
			restrictProfile,
		};
	}

	private async shouldRestrictProfile(viewerId: UserID, targetId: UserID, targetUser: User): Promise<boolean> {
		if (viewerId === targetId) return false;
		if (targetUser.isBot) return false;
		const targetSettings = await this.deps.userAccountRepository.findSettings(targetId);
		const level = targetSettings?.profilePrivacy ?? ProfilePrivacyLevels.ALL_GUILDS;
		if (level === ProfilePrivacyLevels.ALL_GUILDS) {
			if (await this.areFriends(viewerId, targetId)) return false;
			return !(await this.haveMutualGuild(viewerId, targetId));
		}
		if (await this.areFriends(viewerId, targetId)) return false;
		if (level === ProfilePrivacyLevels.FRIENDS_ONLY) return true;
		const sharedGuildIds = await this.getMutualGuildIds(viewerId, targetId);
		if (sharedGuildIds.length === 0) return true;
		const guilds = await Promise.all(sharedGuildIds.map((id) => this.deps.guildRepository.findUnique(id)));
		return !guilds.some((guild) => guild != null && guild.memberCount <= SMALL_GUILD_MEMBER_THRESHOLD);
	}

	private async getMutualGuildIds(userId1: UserID, userId2: UserID): Promise<Array<GuildID>> {
		const [user1GuildIds, user2GuildIds] = await Promise.all([
			this.deps.userAccountRepository.getUserGuildIds(userId1),
			this.deps.userAccountRepository.getUserGuildIds(userId2),
		]);
		const set = new Set(user1GuildIds.map((id) => id.toString()));
		return user2GuildIds.filter((id) => set.has(id.toString()));
	}

	private async validateProfileAccess(userId: UserID, targetId: UserID, targetUser: User): Promise<void> {
		if (targetUser.isBot) {
			return;
		}
		const friendship = await this.deps.userAccountRepository.getRelationship(
			userId,
			targetId,
			RelationshipTypes.FRIEND,
		);
		if (friendship) {
			return;
		}
		const incomingRequest = await this.deps.userAccountRepository.getRelationship(
			userId,
			targetId,
			RelationshipTypes.INCOMING_REQUEST,
		);
		if (incomingRequest) {
			return;
		}
		const outgoingRequest = await this.deps.userAccountRepository.getRelationship(
			userId,
			targetId,
			RelationshipTypes.OUTGOING_REQUEST,
		);
		if (outgoingRequest) {
			return;
		}
		const [userGuildIds, targetGuildIds] = await Promise.all([
			this.deps.userAccountRepository.getUserGuildIds(userId),
			this.deps.userAccountRepository.getUserGuildIds(targetId),
		]);
		const userGuildIdSet = new Set(userGuildIds.map((id) => id.toString()));
		const hasMutualGuild = targetGuildIds.some((id) => userGuildIdSet.has(id.toString()));
		if (hasMutualGuild) {
			return;
		}
		if (await this.hasSharedGroupDm(userId, targetId)) {
			return;
		}
		throw new MissingAccessError();
	}

	private async hasSharedGroupDm(userId: UserID, targetId: UserID): Promise<boolean> {
		const privateChannels = await this.deps.userAccountRepository.listPrivateChannels(userId);
		return privateChannels.some(
			(channel) => channel.type === ChannelTypes.GROUP_DM && channel.recipientIds.has(targetId),
		);
	}

	private async getMutualFriends(userId: UserID, targetId: UserID): Promise<Array<User>> {
		const [userRelationships, targetRelationships] = await Promise.all([
			this.deps.userAccountRepository.listRelationships(userId),
			this.deps.userAccountRepository.listRelationships(targetId),
		]);
		const userFriendIds = new Set(
			userRelationships
				.filter((rel) => rel.type === RelationshipTypes.FRIEND)
				.map((rel) => rel.targetUserId.toString()),
		);
		const mutualFriendIds = targetRelationships
			.filter((rel) => rel.type === RelationshipTypes.FRIEND && userFriendIds.has(rel.targetUserId.toString()))
			.map((rel) => rel.targetUserId);
		if (mutualFriendIds.length === 0) {
			return [];
		}
		const users = await this.deps.userAccountRepository.listUsers(mutualFriendIds);
		return users.sort((a, b) => this.compareUsersByIdDesc(a, b));
	}

	private compareUsersByIdDesc(a: User, b: User): number {
		if (b.id > a.id) return 1;
		if (b.id < a.id) return -1;
		return 0;
	}

	private async getMutualGuilds(
		userId: UserID,
		targetId: UserID,
	): Promise<
		Array<{
			id: string;
			nick: string | null;
		}>
	> {
		const [userGuildIds, targetGuildIds] = await Promise.all([
			this.deps.userAccountRepository.getUserGuildIds(userId),
			this.deps.userAccountRepository.getUserGuildIds(targetId),
		]);
		const userGuildIdSet = new Set(userGuildIds.map((id) => id.toString()));
		const mutualGuildIds = targetGuildIds.filter((id) => userGuildIdSet.has(id.toString()));
		if (mutualGuildIds.length === 0) {
			return [];
		}
		const memberPromises = mutualGuildIds.map((guildId) => this.deps.guildRepository.getMember(guildId, targetId));
		const members = await Promise.all(memberPromises);
		return mutualGuildIds.map((guildId, index) => ({
			id: guildId.toString(),
			nick: members[index]?.nickname ?? null,
		}));
	}

	async checkUsernameDiscriminatorAvailability(params: {
		username: string;
		discriminator: number;
		currentUser: User;
	}): Promise<boolean> {
		const {username, discriminator, currentUser} = params;
		if (hasFixedDiscriminator(currentUser)) {
			return await isUsernameTaken(this.deps.userAccountRepository, username, currentUser.id);
		}
		const isAvailable = await this.deps.discriminatorService.isDiscriminatorAvailableForUsername(
			username,
			discriminator,
		);
		return !isAvailable;
	}

	private async getVisibleConnections(
		targetId: UserID,
		privacyContext: ProfileFieldPrivacyContext,
	): Promise<Array<UserConnectionRow>> {
		const connections = await this.deps.connectionRepository.findByUserId(targetId);
		const verified = connections.filter((connection) => connection.verified);
		return verified.filter((connection) => this.canViewProfileField(connection.visibility_flags, privacyContext));
	}

	private async getProfileFieldPrivacyContext(viewerId: UserID, targetId: UserID): Promise<ProfileFieldPrivacyContext> {
		if (viewerId === targetId) {
			return {isOwner: true, isFriend: true, hasMutualGuild: true};
		}
		const [isFriend, hasMutualGuild] = await Promise.all([
			this.areFriends(viewerId, targetId),
			this.haveMutualGuild(viewerId, targetId),
		]);
		return {isOwner: false, isFriend, hasMutualGuild};
	}

	private canViewProfileField(flags: number, privacyContext: ProfileFieldPrivacyContext): boolean {
		if (privacyContext.isOwner) {
			return flags !== 0;
		}
		if (flags & ProfileFieldPrivacyFlags.EVERYONE) {
			return true;
		}
		if (flags & ProfileFieldPrivacyFlags.FRIENDS && privacyContext.isFriend) {
			return true;
		}
		if (flags & ProfileFieldPrivacyFlags.MUTUAL_GUILDS && privacyContext.hasMutualGuild) {
			return true;
		}
		return false;
	}

	private async areFriends(userId1: UserID, userId2: UserID): Promise<boolean> {
		const friendship = await this.deps.userAccountRepository.getRelationship(
			userId1,
			userId2,
			RelationshipTypes.FRIEND,
		);
		return friendship !== null;
	}

	private async haveMutualGuild(userId1: UserID, userId2: UserID): Promise<boolean> {
		const [user1GuildIds, user2GuildIds] = await Promise.all([
			this.deps.userAccountRepository.getUserGuildIds(userId1),
			this.deps.userAccountRepository.getUserGuildIds(userId2),
		]);
		const user1GuildIdSet = new Set(user1GuildIds.map((id) => id.toString()));
		return user2GuildIds.some((id) => user1GuildIdSet.has(id.toString()));
	}
}