Skip to content

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

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

import type {ApiContext} from '@app/api/ApiContext';
import type {SudoVerificationResult} from '@app/api/auth/services/SudoVerificationService';
import {Config} from '@app/api/Config';
import type {ConnectionRepository} from '@app/api/connection/ConnectionRepository';
import type {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import type {GuildService} from '@app/api/guild/services/GuildService';
import {GuildMemberSearchIndexService} from '@app/api/guild/services/member/GuildMemberSearchIndexService';
import type {DiscriminatorService} from '@app/api/infrastructure/DiscriminatorService';
import type {EntityAssetService} from '@app/api/infrastructure/EntityAssetService';
import type {KVAccountDeletionQueueService} from '@app/api/infrastructure/KVAccountDeletionQueueService';
import type {UserCacheService} from '@app/api/infrastructure/UserCacheService';
import {Logger} from '@app/api/Logger';
import type {LimitConfigService} from '@app/api/limits/LimitConfigService';
import {getOperatorPassWallService} from '@app/api/middleware/ServiceSingletons';
import type {AuthSession} from '@app/api/models/AuthSession';
import type {User} from '@app/api/models/User';
import {enqueueStripeCustomerEmailSync} from '@app/api/stripe/StripeCustomer';
import {isOperatorPassCountHidden} from '@app/api/user/profile_badges/PremiumBadgeMasking';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {
	type PartialUserChangePropagationDeps,
	propagateUserUpdate,
} from '@app/api/user/services/PartialUserChangePropagation';
import {UserAccountLifecycleService} from '@app/api/user/services/UserAccountLifecycleService';
import {UserAccountLookupService} from '@app/api/user/services/UserAccountLookupService';
import {UserAccountNotesService} from '@app/api/user/services/UserAccountNotesService';
import {UserAccountProfileService} from '@app/api/user/services/UserAccountProfileService';
import {
	type AuthSessionReplacement,
	UserAccountSecurityService,
} from '@app/api/user/services/UserAccountSecurityService';
import {UserAccountSettingsService} from '@app/api/user/services/UserAccountSettingsService';
import {UserAccountUpdatePropagator} from '@app/api/user/services/UserAccountUpdatePropagator';
import type {UserContactChangeLogService} from '@app/api/user/services/UserContactChangeLogService';
import {createPremiumClearPatch} from '@app/api/user/UserHelpers';
import {runAllInOrder} from '@app/api/utils/ConcurrencyUtils';
import {PremiumFlags} from '@fluxer/constants/src/UserConstants';
import type {UserUpdateRequest} from '@fluxer/schema/src/domains/user/UserRequestSchemas';

interface UpdateUserParams {
	user: User;
	oldAuthSession: AuthSession;
	data: UserUpdateRequest;
	request: Request;
	sudoContext?: SudoVerificationResult;
	emailVerifiedViaToken?: boolean;
}

interface UpdateUserResult {
	user: User;
	authSessionReplacement: AuthSessionReplacement | null;
}

export class UserAccountService {
	readonly lookupService: UserAccountLookupService;
	private readonly profileService: UserAccountProfileService;
	private readonly securityService: UserAccountSecurityService;
	readonly settingsService: UserAccountSettingsService;
	readonly notesService: UserAccountNotesService;
	readonly lifecycleService: UserAccountLifecycleService;
	readonly updatePropagator: UserAccountUpdatePropagator;
	private readonly userUpdateDeps: PartialUserChangePropagationDeps;
	private readonly userAccountRepository: UserRepository;
	private readonly guildRepository: GuildRepository;
	private readonly searchIndexService: GuildMemberSearchIndexService;

	constructor(
		private readonly apiContext: ApiContext,
		userCacheService: UserCacheService,
		guildService: GuildService,
		entityAssetService: EntityAssetService,
		guildRepository: GuildRepository,
		discriminatorService: DiscriminatorService,
		kvDeletionQueue: KVAccountDeletionQueueService,
		private readonly contactChangeLogService: UserContactChangeLogService,
		connectionRepository: ConnectionRepository,
		readonly limitConfigService: LimitConfigService,
	) {
		const {
			users: userAccountRepository,
			gateway: gatewayService,
			email: emailService,
			rateLimit: rateLimitService,
		} = this.apiContext.services;
		this.userUpdateDeps = {userCacheService, gatewayService, userRepository: userAccountRepository, guildRepository};
		this.userAccountRepository = userAccountRepository;
		this.guildRepository = guildRepository;
		this.searchIndexService = new GuildMemberSearchIndexService();
		this.updatePropagator = new UserAccountUpdatePropagator({gatewayService});
		this.lookupService = new UserAccountLookupService({
			userAccountRepository,

			guildRepository,
			guildService,
			discriminatorService,
			connectionRepository,
		});
		this.profileService = new UserAccountProfileService({
			userAccountRepository,
			guildRepository,
			entityAssetService,
			rateLimitService,
			limitConfigService,
		});
		this.securityService = new UserAccountSecurityService({
			apiContext: this.apiContext,
			userAccountRepository,
			discriminatorService,
			rateLimitService,
			limitConfigService,
		});
		this.settingsService = new UserAccountSettingsService({
			userAccountRepository,

			updatePropagator: this.updatePropagator,
			gatewayService,
			userCacheService,
			guildRepository,
			limitConfigService,
			cacheService: this.apiContext.services.cache,
		});
		this.notesService = new UserAccountNotesService({
			userAccountRepository,

			updatePropagator: this.updatePropagator,
		});
		this.lifecycleService = new UserAccountLifecycleService({
			apiContext: this.apiContext,
			userAccountRepository,
			guildRepository,
			emailService,
			userUpdateDeps: this.userUpdateDeps,
			kvDeletionQueue,
		});
	}

	async update(params: UpdateUserParams): Promise<UpdateUserResult> {
		const {user, oldAuthSession, data, request, sudoContext, emailVerifiedViaToken = false} = params;
		const profileResult = await this.profileService.processProfileUpdates({user, data});
		const securityResult = await this.securityService
			.processSecurityUpdates({user, data, sudoContext})
			.catch(async (error: unknown) => {
				await this.profileService.rollbackAssetUploads(profileResult);
				throw error;
			});
		const updates = {
			...securityResult.updates,
			...profileResult.updates,
		};
		const securityPremiumFlags = securityResult.updates.premium_flags;
		if (securityPremiumFlags !== undefined && securityPremiumFlags !== null) {
			const profilePremiumFlags = profileResult.updates.premium_flags ?? user.premiumFlags;
			updates.premium_flags = profilePremiumFlags | (securityPremiumFlags & ~user.premiumFlags);
		}
		const emailChanged = data.email !== undefined;
		if (emailChanged) {
			updates.email_verified = !!emailVerifiedViaToken;
		}
		let updatedUser: User;
		try {
			updatedUser = await this.userAccountRepository.patchUpsert(user.id, updates, user.toRow());
		} catch (error) {
			Logger.error(
				{error, userId: user.id},
				'User profile update failed with unknown commit status; retaining uploaded assets',
			);
			throw error;
		} finally {
			await securityResult.metadata.usernameReservation?.release();
		}
		const finalizationSteps: Array<() => Promise<unknown>> = [
			() =>
				this.contactChangeLogService.recordDiff({
					oldUser: user,
					newUser: updatedUser,
					reason: 'user_requested',
					actorUserId: user.id,
				}),
			() => enqueueStripeCustomerEmailSync(this.apiContext.services.worker, user, updatedUser),
			async () => {
				try {
					await this.profileService.commitAssetChanges(profileResult);
				} catch (error) {
					Logger.error({error, userId: user.id}, 'Failed to commit asset changes after successful DB update');
				}
			},
			() => propagateUserUpdate(this.userUpdateDeps, user, updatedUser, {continueAfterDispatchFailure: true}),
			async () => {
				const changed =
					user.username !== updatedUser.username ||
					user.globalName !== updatedUser.globalName ||
					user.avatarHash !== updatedUser.avatarHash;
				if (!changed || Config.instance.selfHosted) {
					return;
				}
				try {
					await getOperatorPassWallService().onProfileChanged(updatedUser, {
						username: user.username,
						globalName: user.globalName,
						avatarHash: user.avatarHash,
					});
				} catch (error) {
					Logger.error({error, userId: user.id}, "Failed to follow a profile change on the Operators' wall");
				}
			},
			async () => {
				if (
					Config.instance.selfHosted ||
					isOperatorPassCountHidden(user.premiumFlags) === isOperatorPassCountHidden(updatedUser.premiumFlags)
				) {
					return;
				}
				try {
					await getOperatorPassWallService().publication.publishChanges([updatedUser.id], 'preserve');
				} catch (error) {
					Logger.error({error, userId: user.id}, "Failed to publish an Operators' wall count visibility change");
				}
			},
			async () => {
				const nameChanged =
					user.username !== updatedUser.username ||
					user.discriminator !== updatedUser.discriminator ||
					user.globalName !== updatedUser.globalName;
				if (nameChanged) {
					void this.reindexGuildMembersForUser(updatedUser);
				}
			},
		];
		let authSessionReplacement: AuthSessionReplacement | null = null;
		if (securityResult.metadata.invalidateAuthSessions) {
			finalizationSteps.push(
				async () => {
					authSessionReplacement = await this.securityService.invalidateAndRecreateSessions({
						user,
						oldAuthSession,
						request,
					});
				},
				() => this.userAccountRepository.deleteAllPasswordResetTokens(user.id),
			);
		}
		await runAllInOrder(finalizationSteps, 'Failed to finalize user update');
		return {user: updatedUser, authSessionReplacement};
	}

	private async reindexGuildMembersForUser(updatedUser: User): Promise<void> {
		try {
			const guildIds = await this.userAccountRepository.getUserGuildIds(updatedUser.id);
			await this.searchIndexService.updateUserMembers(updatedUser, guildIds, this.guildRepository);
		} catch (error) {
			Logger.error({userId: updatedUser.id.toString(), error}, 'Failed to reindex guild members after user update');
		}
	}

	async resetCurrentUserPremiumState(user: User): Promise<void> {
		const updates = {
			...createPremiumClearPatch(),
			premium_lifetime_sequence: null,
			stripe_subscription_id: null,
			stripe_customer_id: null,
			has_ever_purchased: null,
			first_refund_at: null,
			gift_inventory_server_seq: null,
			gift_inventory_client_seq: null,
			premium_flags: user.premiumFlags & ~PremiumFlags.ENABLED_OVERRIDE,
		};
		const updatedUser = await this.userAccountRepository.patchUpsert(user.id, updates, user.toRow());
		await propagateUserUpdate(this.userUpdateDeps, user, updatedUser);
	}
}