A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// 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);
}
}