Skip to content

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

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

import type {UserRow} from '@app/api/database/types/UserTypes';
import type {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import {contentModerationService} from '@app/api/infrastructure/ContentModerationService';
import type {EntityAssetService, PreparedAssetUpload} from '@app/api/infrastructure/EntityAssetService';
import type {LimitConfigService} from '@app/api/limits/LimitConfigService';
import {resolveLimitSafe} from '@app/api/limits/LimitConfigUtils';
import {createLimitMatchContext} from '@app/api/limits/LimitMatchContextBuilder';
import {profileSubstringBlocklistCache} from '@app/api/middleware/ProfileSubstringBlocklistCache';
import {getCustomBadgeCatalog} from '@app/api/middleware/ServiceSingletons';
import type {User} from '@app/api/models/User';
import {
	dropUndefinedCustomBadgeKeys,
	hiddenCustomBadgeIds,
	resolveHiddenProfileBadges,
} from '@app/api/user/profile_badges/HiddenProfileBadges';
import {applyProfileBadgeSettings} from '@app/api/user/profile_badges/PremiumBadgeMasking';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {isProfileSubstringExempt} from '@app/api/user/UserHelpers';
import {deriveDominantAvatarColor} from '@app/api/utils/AvatarColorUtils';
import * as EmojiUtils from '@app/api/utils/EmojiUtils';
import {CustomBadgeTypes} from '@fluxer/constants/src/BadgeConstants';
import {MAX_BIO_LENGTH} from '@fluxer/constants/src/LimitConstants';
import {PremiumFlags, ProfileFieldPrivacyFlags, UserFlags} from '@fluxer/constants/src/UserConstants';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
import {isSupportedTimeZoneId} from '@fluxer/date_utils/src/TimeZoneUtils';
import {ContentBlockedError} from '@fluxer/errors/src/domains/content/ContentBlockedError';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
import {MissingAccessError} from '@fluxer/errors/src/domains/core/MissingAccessError';
import type {UserUpdateRequest} from '@fluxer/schema/src/domains/user/UserRequestSchemas';
import type {IRateLimitService} from '@pkgs/rate_limit/src/IRateLimitService';
import {ms} from 'itty-time';

type UserFieldUpdates = Partial<UserRow>;

interface ProfileUpdateResult {
	updates: UserFieldUpdates;
	preparedAvatarUpload: PreparedAssetUpload | null;
	preparedBannerUpload: PreparedAssetUpload | null;
}

interface UserAccountProfileServiceDeps {
	userAccountRepository: UserRepository;
	guildRepository: GuildRepository;
	entityAssetService: EntityAssetService;
	rateLimitService: IRateLimitService;
	limitConfigService: LimitConfigService;
}

export class UserAccountProfileService {
	constructor(private readonly deps: UserAccountProfileServiceDeps) {}

	async processProfileUpdates(params: {user: User; data: UserUpdateRequest}): Promise<ProfileUpdateResult> {
		const {user, data} = params;
		const updates: UserFieldUpdates = {
			avatar_hash: user.avatarHash,
			banner_hash: user.bannerHash,
		};
		let preparedAvatarUpload: PreparedAssetUpload | null = null;
		let preparedBannerUpload: PreparedAssetUpload | null = null;
		if (data.bio !== undefined) {
			contentModerationService.scanText(data.bio, {
				userId: user.id,
				guildId: null,
				channelId: null,
				messageId: null,
				surface: 'profile_field',
			});
			await this.processBioUpdate({user, bio: data.bio, updates});
		}
		if (data.pronouns !== undefined) {
			contentModerationService.scanText(data.pronouns, {
				userId: user.id,
				guildId: null,
				channelId: null,
				messageId: null,
				surface: 'profile_field',
			});
			await this.processPronounsUpdate({user, pronouns: data.pronouns, updates});
		}
		if (data.accent_color !== undefined) {
			await this.processAccentColorUpdate({user, accentColor: data.accent_color, updates});
		}
		if (data.timezone !== undefined) {
			const nextTimezone = this.processTimezoneUpdate({user, timezone: data.timezone, updates});
			if (nextTimezone !== null && user.timezone === null && data.timezone_privacy_flags === undefined) {
				updates.timezone_privacy_flags = ProfileFieldPrivacyFlags.EVERYONE;
			}
		}
		if (data.timezone_privacy_flags !== undefined) {
			this.processTimezonePrivacyFlagsUpdate({
				user,
				privacyFlags: data.timezone_privacy_flags,
				updates,
			});
		}
		if (!user.isBot) {
			this.processPremiumBadgeFlags({user, data, updates});
			await this.processHiddenProfileBadges({user, data, updates});
		}
		if (data.avatar !== undefined) {
			preparedAvatarUpload = await this.processAvatarUpdate({user, avatar: data.avatar, updates});
		}
		if (data.banner !== undefined) {
			try {
				preparedBannerUpload = await this.processBannerUpdate({user, banner: data.banner, updates});
			} catch (error) {
				if (preparedAvatarUpload) {
					await this.deps.entityAssetService.rollbackAssetUpload(preparedAvatarUpload);
				}
				throw error;
			}
		}
		if (!user.isBot) {
			this.processPremiumOnboardingDismissal({data, updates});
			this.processGiftInventoryRead({user, data, updates});
		}
		if (data.mention_flags !== undefined) {
			updates.mention_flags = data.mention_flags;
		}
		return {updates, preparedAvatarUpload, preparedBannerUpload};
	}

	async commitAssetChanges(result: ProfileUpdateResult): Promise<void> {
		await this.deps.entityAssetService.commitAssetChanges([result.preparedAvatarUpload, result.preparedBannerUpload]);
	}

	async rollbackAssetUploads(result: ProfileUpdateResult): Promise<void> {
		for (const prepared of [result.preparedAvatarUpload, result.preparedBannerUpload]) {
			if (prepared) {
				await this.deps.entityAssetService.rollbackAssetUpload(prepared);
			}
		}
	}

	private async processBioUpdate(params: {user: User; bio: string | null; updates: UserFieldUpdates}): Promise<void> {
		const {user, bio, updates} = params;
		if (bio !== user.bio) {
			const bioRateLimit = await this.deps.rateLimitService.checkLimit({
				identifier: `bio_change:${user.id}`,
				maxAttempts: 25,
				windowMs: ms('30 minutes'),
			});
			if (!bioRateLimit.allowed) {
				const minutes = Math.ceil((bioRateLimit.retryAfter || 0) / 60);
				throw InputValidationError.fromCode('bio', ValidationErrorCodes.BIO_CHANGED_TOO_MANY_TIMES, {minutes});
			}
			const ctx = createLimitMatchContext({user});
			const maxBioLength = resolveLimitSafe(
				this.deps.limitConfigService.getConfigSnapshot(),
				ctx,
				'max_bio_length',
				MAX_BIO_LENGTH,
			);
			if (bio && bio.length > maxBioLength) {
				throw InputValidationError.fromCode('bio', ValidationErrorCodes.CONTENT_EXCEEDS_MAX_LENGTH, {
					maxLength: maxBioLength,
				});
			}
			let sanitizedBio = bio;
			if (bio) {
				sanitizedBio = await EmojiUtils.sanitizeCustomEmojis({
					content: bio,
					userId: user.id,
					webhookId: null,
					guildId: null,
					userRepository: this.deps.userAccountRepository,
					guildRepository: this.deps.guildRepository,
					limitConfigService: this.deps.limitConfigService,
					allowCodeBlocks: false,
				});
			}
			if (
				sanitizedBio &&
				!isProfileSubstringExempt(user) &&
				profileSubstringBlocklistCache.containsBannedSubstring('bio', sanitizedBio)
			) {
				throw new ContentBlockedError();
			}
			updates.bio = sanitizedBio;
		}
	}

	private async processPronounsUpdate(params: {
		user: User;
		pronouns: string | null;
		updates: UserFieldUpdates;
	}): Promise<void> {
		const {user, pronouns, updates} = params;
		if (pronouns !== user.pronouns) {
			const pronounsRateLimit = await this.deps.rateLimitService.checkLimit({
				identifier: `pronouns_change:${user.id}`,
				maxAttempts: 25,
				windowMs: ms('30 minutes'),
			});
			if (!pronounsRateLimit.allowed) {
				const minutes = Math.ceil((pronounsRateLimit.retryAfter || 0) / 60);
				throw InputValidationError.fromCode('pronouns', ValidationErrorCodes.PRONOUNS_CHANGED_TOO_MANY_TIMES, {
					minutes,
				});
			}
			if (
				pronouns &&
				!isProfileSubstringExempt(user) &&
				profileSubstringBlocklistCache.containsBannedSubstring('pronouns', pronouns)
			) {
				throw new ContentBlockedError();
			}
			updates.pronouns = pronouns;
		}
	}

	private async processAccentColorUpdate(params: {
		user: User;
		accentColor: number | null;
		updates: UserFieldUpdates;
	}): Promise<void> {
		const {user, accentColor, updates} = params;
		if (accentColor !== user.accentColor) {
			const accentColorRateLimit = await this.deps.rateLimitService.checkLimit({
				identifier: `accent_color_change:${user.id}`,
				maxAttempts: 25,
				windowMs: ms('30 minutes'),
			});
			if (!accentColorRateLimit.allowed) {
				const minutes = Math.ceil((accentColorRateLimit.retryAfter || 0) / 60);
				throw InputValidationError.fromCode('accent_color', ValidationErrorCodes.ACCENT_COLOR_CHANGED_TOO_MANY_TIMES, {
					minutes,
				});
			}
			updates.accent_color = accentColor;
		}
	}

	private processTimezoneUpdate(params: {
		user: User;
		timezone: string | null;
		updates: UserFieldUpdates;
	}): string | null {
		const {user, timezone, updates} = params;
		const nextTimezone = timezone?.trim() || null;
		if (nextTimezone !== null && !isSupportedTimeZoneId(nextTimezone)) {
			throw InputValidationError.fromCode('timezone', ValidationErrorCodes.INVALID_TIMEZONE_IDENTIFIER);
		}
		if (nextTimezone !== user.timezone) {
			updates.timezone = nextTimezone;
		}
		return nextTimezone;
	}

	private processTimezonePrivacyFlagsUpdate(params: {
		user: User;
		privacyFlags: number;
		updates: UserFieldUpdates;
	}): void {
		const {user, privacyFlags, updates} = params;
		if (privacyFlags !== user.timezonePrivacyFlags) {
			updates.timezone_privacy_flags = privacyFlags;
		}
	}

	private async processAvatarUpdate(params: {
		user: User;
		avatar: string | null;
		updates: UserFieldUpdates;
	}): Promise<PreparedAssetUpload | null> {
		const {user, avatar, updates} = params;
		if (avatar === null) {
			updates.avatar_hash = null;
			updates.avatar_color = null;
			if (user.avatarHash) {
				return await this.deps.entityAssetService.prepareAssetUpload({
					assetType: 'avatar',
					entityType: 'user',
					entityId: user.id,
					previousHash: user.avatarHash,
					base64Image: null,
					errorPath: 'avatar',
				});
			}
			return null;
		}
		const avatarRateLimit = await this.deps.rateLimitService.checkLimit({
			identifier: `avatar_change:${user.id}`,
			maxAttempts: 25,
			windowMs: ms('30 minutes'),
		});
		if (!avatarRateLimit.allowed) {
			const minutes = Math.ceil((avatarRateLimit.retryAfter || 0) / 60);
			throw InputValidationError.fromCode('avatar', ValidationErrorCodes.AVATAR_CHANGED_TOO_MANY_TIMES, {minutes});
		}
		const prepared = await this.deps.entityAssetService.prepareAssetUpload({
			assetType: 'avatar',
			entityType: 'user',
			entityId: user.id,
			previousHash: user.avatarHash,
			base64Image: avatar,
			errorPath: 'avatar',
			uploader: user,
		});
		const ctx = createLimitMatchContext({user});
		const hasAnimatedAvatar = resolveLimitSafe(
			this.deps.limitConfigService.getConfigSnapshot(),
			ctx,
			'feature_animated_avatar',
			0,
		);
		if (prepared.isAnimated && hasAnimatedAvatar === 0) {
			await this.deps.entityAssetService.rollbackAssetUpload(prepared);
			throw InputValidationError.fromCode('avatar', ValidationErrorCodes.ANIMATED_AVATARS_REQUIRE_PREMIUM);
		}
		if (prepared.imageBuffer) {
			const derivedColor = await deriveDominantAvatarColor(prepared.imageBuffer);
			if (derivedColor !== user.avatarColor) {
				updates.avatar_color = derivedColor;
			}
		}
		if (prepared.newHash !== user.avatarHash) {
			updates.avatar_hash = prepared.newHash;
			return prepared;
		}
		return null;
	}

	private async processBannerUpdate(params: {
		user: User;
		banner: string | null;
		updates: UserFieldUpdates;
	}): Promise<PreparedAssetUpload | null> {
		const {user, banner, updates} = params;
		if (banner === null) {
			updates.banner_color = null;
		}
		const ctx = createLimitMatchContext({user});
		const hasAnimatedBanner = resolveLimitSafe(
			this.deps.limitConfigService.getConfigSnapshot(),
			ctx,
			'feature_animated_banner',
			0,
		);
		if (banner !== null && hasAnimatedBanner === 0) {
			throw InputValidationError.fromCode('banner', ValidationErrorCodes.BANNERS_REQUIRE_PREMIUM);
		}
		const bannerRateLimit = await this.deps.rateLimitService.checkLimit({
			identifier: `banner_change:${user.id}`,
			maxAttempts: 25,
			windowMs: ms('30 minutes'),
		});
		if (!bannerRateLimit.allowed) {
			const minutes = Math.ceil((bannerRateLimit.retryAfter || 0) / 60);
			throw InputValidationError.fromCode('banner', ValidationErrorCodes.BANNER_CHANGED_TOO_MANY_TIMES, {minutes});
		}
		const prepared = await this.deps.entityAssetService.prepareAssetUpload({
			assetType: 'banner',
			entityType: 'user',
			entityId: user.id,
			previousHash: user.bannerHash,
			base64Image: banner,
			errorPath: 'banner',
			uploader: user,
		});
		if (prepared.isAnimated && hasAnimatedBanner === 0) {
			await this.deps.entityAssetService.rollbackAssetUpload(prepared);
			throw InputValidationError.fromCode('banner', ValidationErrorCodes.ANIMATED_AVATARS_REQUIRE_PREMIUM);
		}
		if (banner !== null && prepared.imageBuffer) {
			const derivedColor = await deriveDominantAvatarColor(prepared.imageBuffer);
			if (derivedColor !== user.bannerColor) {
				updates.banner_color = derivedColor;
			}
		}
		if (prepared.newHash !== user.bannerHash) {
			updates.banner_hash = prepared.newHash;
			return prepared;
		}
		return null;
	}

	private processPremiumBadgeFlags(params: {user: User; data: UserUpdateRequest; updates: UserFieldUpdates}): void {
		const {user, data, updates} = params;
		if (data.premium_enabled_override !== undefined && !(user.flags & UserFlags.STAFF)) {
			throw new MissingAccessError();
		}
		const current = updates.premium_flags ?? user.premiumFlags;
		let flags = applyProfileBadgeSettings(current, data);
		if (data.premium_enabled_override !== undefined) {
			flags = data.premium_enabled_override
				? flags | PremiumFlags.ENABLED_OVERRIDE
				: flags & ~PremiumFlags.ENABLED_OVERRIDE;
		}
		if (flags !== current) {
			updates.premium_flags = flags;
		}
	}

	private async processHiddenProfileBadges(params: {
		user: User;
		data: UserUpdateRequest;
		updates: UserFieldUpdates;
	}): Promise<void> {
		const {user, data, updates} = params;
		const requested = resolveHiddenProfileBadges(user.hiddenProfileBadges, data);
		if (!requested) return;
		const known = await getCustomBadgeCatalog().getByIds(hiddenCustomBadgeIds(requested), CustomBadgeTypes.USER);
		const next = dropUndefinedCustomBadgeKeys(requested, new Set(known.map((badge) => badge.id)));
		if (next.size === user.hiddenProfileBadges.size && [...next].every((key) => user.hiddenProfileBadges.has(key))) {
			return;
		}
		updates.hidden_profile_badges = next.size > 0 ? next : null;
	}

	private processPremiumOnboardingDismissal(params: {data: UserUpdateRequest; updates: UserFieldUpdates}): void {
		const {data, updates} = params;
		if (data.has_dismissed_premium_onboarding) {
			updates.premium_onboarding_dismissed_at = new Date();
		}
	}

	private processGiftInventoryRead(params: {user: User; data: UserUpdateRequest; updates: UserFieldUpdates}): void {
		const {user, data, updates} = params;
		if (data.has_unread_gift_inventory === false) {
			updates.gift_inventory_client_seq = user.giftInventoryServerSeq;
		}
	}
}