Skip to content

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

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

import {revokeAllAuthSessions} from '@app/api/auth/AuthSessionRevocation';
import type {UserID} from '@app/api/BrandedTypes';
import {Config} from '@app/api/Config';
import {SYSTEM_USER_ID} from '@app/api/constants/Core';
import {EnforcementDecisionRepository} from '@app/api/enforcement/EnforcementDecisionRepository';
import {clearExpiredSuspension} from '@app/api/enforcement/SuspensionState';
import type {IGatewayService} from '@app/api/infrastructure/IGatewayService';
import type {KVAccountDeletionQueueService} from '@app/api/infrastructure/KVAccountDeletionQueueService';
import type {KVActivityTracker} from '@app/api/infrastructure/KVActivityTracker';
import {Logger} from '@app/api/Logger';
import type {User} from '@app/api/models/User';
import {followOperatorPassWallStanding} from '@app/api/operator_pass/OperatorPassWallStanding';
import {scheduleSystemDeletion} from '@app/api/user/AccountCleanup';
import {hasWayBackIn} from '@app/api/user/AccountTier';
import {isDateOfBirthMissing} from '@app/api/user/DateOfBirth';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {
	type PartialUserChangePropagationDeps,
	propagateUserUpdate,
} from '@app/api/user/services/PartialUserChangePropagation';
import {reschedulePendingDeletion} from '@app/api/user/services/PendingDeletionCoordinator';
import type {UserDeletionEligibilityService} from '@app/api/user/services/UserDeletionEligibilityService';
import {isDeletionComplete} from '@app/api/user/UserHelpers';
import {DOB_DEFERRED_TRAIT} from '@app/api/user/UserTraits';
import {mapWithConcurrency} from '@app/api/utils/ConcurrencyUtils';
import {getWorkerDependencies} from '@app/api/worker/WorkerContext';
import {
	AccountCleanupDefaults,
	CleanupModes,
	LastSessionCleanupModes,
} from '@fluxer/constants/src/AccountConfigConstants';
import {DeletionReasons} from '@fluxer/constants/src/Core';
import {UserFlags} from '@fluxer/constants/src/UserConstants';
import type {AccountsConfig} from '@fluxer/schema/src/domains/admin/AccountsConfigSchemas';
import {snowflakeToDate} from '@fluxer/snowflake/src/Snowflake';
import type {IEmailService} from '@pkgs/email/src/IEmailService';
import {TestEmailService} from '@pkgs/email/src/TestEmailService';
import type {IKVProvider} from '@pkgs/kv_client/src/IKVProvider';
import type {WorkerTaskHandler} from '@pkgs/worker/src/contracts/WorkerTask';
import {ms} from 'itty-time';

const BATCH_SIZE = 100;
const USER_PROCESSING_CONCURRENCY = 8;

interface InactivityCheckResult {
	warningsSent: number;
	deletionsScheduled: number;
	suspensionsCleared: number;
	errors: number;
}

async function scheduleDeletion(
	userRepository: UserRepository,
	deletionQueueService: KVAccountDeletionQueueService,
	gatewayService: IGatewayService,
	user: User,
	userId: UserID,
): Promise<void> {
	const gracePeriodMs = Config.deletionGracePeriodHours * ms('1 hour');
	const pendingDeletionAt = new Date(Date.now() + gracePeriodMs);
	const updated = await userRepository.updateDeletionSchedule(user, {
		flags: user.flags | UserFlags.SELF_DELETED,
		pending_deletion_at: pendingDeletionAt,
		deletion_reason_code: DeletionReasons.INACTIVITY,
		deletion_scheduled_by: SYSTEM_USER_ID,
		deletion_scheduled_at: new Date(),
	});
	await reschedulePendingDeletion({
		userId,
		currentPendingDeletionAt: user.pendingDeletionAt,
		nextPendingDeletionAt: pendingDeletionAt,
		deletionReasonCode: DeletionReasons.INACTIVITY,
		deletionQueue: deletionQueueService,
	});
	await revokeAllAuthSessions({users: userRepository, gateway: gatewayService}, userId);
	await followOperatorPassWallStanding(user, updated);
	Logger.debug({userId, pendingDeletionAt, reason: 'INACTIVITY'}, 'Scheduled inactive user for deletion');
}

type AccountCleanupConfig = Pick<
	AccountsConfig,
	'unclaimed_account_cleanup' | 'dob_missing_cleanup' | 'inactivity_deletion'
>;

function daysMs(days: number): number {
	return days * ms('1 day');
}

function sweepsAbandonedAccounts(cleanup: AccountCleanupConfig): boolean {
	return (
		cleanup.dob_missing_cleanup.mode !== CleanupModes.OFF ||
		cleanup.unclaimed_account_cleanup.mode !== CleanupModes.OFF ||
		cleanup.unclaimed_account_cleanup.on_last_session_end !== LastSessionCleanupModes.OFF
	);
}

interface ProcessUserDeps {
	cleanup: AccountCleanupConfig;
	userRepository: UserRepository;
	deletionQueueService: KVAccountDeletionQueueService;
	gatewayService: IGatewayService;
	emailService: IEmailService;
	isEmailEnabled: () => Promise<boolean>;
	activityTracker: KVActivityTracker;
	deletionEligibilityService: UserDeletionEligibilityService;
	decisionRepository: Pick<EnforcementDecisionRepository, 'get' | 'endIfActive'>;
	userUpdateDeps: PartialUserChangePropagationDeps;
}

async function clearSuspensionIfExpired(
	user: User,
	deps: ProcessUserDeps,
	result: InactivityCheckResult,
): Promise<User> {
	const expiry = await clearExpiredSuspension({users: deps.userRepository, repository: deps.decisionRepository}, user);
	if (!expiry) return user;
	await propagateUserUpdate(deps.userUpdateDeps, expiry.previous, expiry.cleared);
	result.suspensionsCleared++;
	Logger.debug({userId: user.id}, 'Cleared an expired suspension');
	return expiry.cleared;
}

async function loadPageActivities(
	activityTracker: KVActivityTracker,
	users: ReadonlyArray<User>,
): Promise<ReadonlyMap<UserID, Date | null> | null> {
	try {
		return await activityTracker.getActivities(users.map((user) => user.id));
	} catch (error) {
		Logger.warn({error}, 'Batched activity lookup failed, falling back to per-user activity lookups');
		return null;
	}
}

async function processUser(
	listedUser: User,
	deps: ProcessUserDeps,
	pageActivities: ReadonlyMap<UserID, Date | null> | null,
	result: InactivityCheckResult,
): Promise<void> {
	const {
		userRepository,
		deletionQueueService,
		gatewayService,
		emailService,
		isEmailEnabled,
		activityTracker,
		deletionEligibilityService,
	} = deps;
	if (isDeletionComplete(listedUser)) return;
	const user = await clearSuspensionIfExpired(listedUser, deps, result);
	const userId = user.id;
	if (user.pendingDeletionAt) {
		Logger.debug({userId}, 'User already pending deletion, skipping');
		return;
	}
	if (user.isBot) {
		Logger.debug({userId}, 'User is a bot, skipping');
		return;
	}
	if (user.flags & UserFlags.APP_STORE_REVIEWER) {
		Logger.debug({userId}, 'User is an app store reviewer, skipping');
		return;
	}
	const prefetchedActivity = pageActivities?.get(userId);
	const lastActivity =
		prefetchedActivity !== undefined ? prefetchedActivity : await activityTracker.getActivity(userId);
	const now = new Date();
	const userInactiveMs = lastActivity ? now.getTime() - lastActivity.getTime() : Infinity;
	if (sweepsAbandonedAccounts(deps.cleanup)) {
		const lastKnownActivity = lastActivity ?? user.lastActiveAt ?? snowflakeToDate(BigInt(userId));
		const abandonedInactiveMs = now.getTime() - lastKnownActivity.getTime();
		const reasonCode = await abandonedAccountReason(user, abandonedInactiveMs, userRepository, deps.cleanup);
		const current = reasonCode === null ? null : await userRepository.findUnique(userId);
		const currentReason =
			current === null ||
			current.pendingDeletionAt ||
			(await deletionEligibilityService.isProtectedFromSystemDeletion(current))
				? null
				: await abandonedAccountReason(current, abandonedInactiveMs, userRepository, deps.cleanup);
		if (current !== null && currentReason !== null) {
			await scheduleSystemDeletion(
				{users: userRepository, gateway: gatewayService, deletionQueue: deletionQueueService},
				current,
				{
					reasonCode: currentReason,
					delayMs: AccountCleanupDefaults.SCHEDULED_DELETION_GRACE_MS,
					cancelledBySignIn: true,
					endSessions: true,
				},
			);
			result.deletionsScheduled++;
			return;
		}
	}
	const inactivity = deps.cleanup.inactivity_deletion;
	if (inactivity.mode === CleanupModes.OFF || userInactiveMs < daysMs(inactivity.inactive_days)) {
		return;
	}
	const isEligible = await deletionEligibilityService.isEligibleForInactivityDeletion(user);
	if (!isEligible) {
		Logger.debug({userId}, 'User not eligible for inactivity deletion');
		return;
	}
	const hasWarningSent = await deletionEligibilityService.hasWarningSent(userId);
	if (hasWarningSent) {
		const hasGracePeriodExpired = await deletionEligibilityService.hasWarningGracePeriodExpired(userId);
		if (hasGracePeriodExpired) {
			Logger.debug({userId}, 'Warning grace period expired, scheduling deletion');
			await scheduleDeletion(userRepository, deletionQueueService, gatewayService, user, userId);
			result.deletionsScheduled++;
		} else {
			Logger.debug({userId}, 'Warning grace period still active, skipping (idempotency check)');
		}
		return;
	}
	const isTestRun = Config.dev.testModeEnabled;
	const usingTestEmailService = emailService instanceof TestEmailService;
	const canSendEmail = !!user.email && (usingTestEmailService || isTestRun || (await isEmailEnabled()));
	if (!canSendEmail) {
		return;
	}
	try {
		const deletionDate = new Date(now.getTime() + daysMs(inactivity.warning_lead_days));
		const sent = await emailService.send(
			'inactivity_warning',
			user.email,
			{deletionDate, lastActiveDate: lastActivity ?? snowflakeToDate(BigInt(userId))},
			user.locale,
		);
		if (sent) {
			await deletionEligibilityService.markWarningSent(userId);
			result.warningsSent++;
			Logger.debug({userId, email: user.email}, 'Sent inactivity warning email');
		}
	} catch (emailError) {
		Logger.error({error: emailError, userId, email: user.email}, 'Failed to send inactivity warning email');
		result.errors++;
	}
}

async function abandonedAccountReason(
	user: User,
	inactiveMs: number,
	userRepository: UserRepository,
	cleanup: AccountCleanupConfig,
): Promise<number | null> {
	const dobMissing = cleanup.dob_missing_cleanup;
	if (
		dobMissing.mode === CleanupModes.AFTER_INACTIVITY &&
		user.traits.has(DOB_DEFERRED_TRAIT) &&
		isDateOfBirthMissing(user) &&
		inactiveMs >= daysMs(dobMissing.inactive_days)
	) {
		return DeletionReasons.INACTIVITY;
	}
	const unclaimed = cleanup.unclaimed_account_cleanup;
	const afterInactivity = unclaimed.mode === CleanupModes.AFTER_INACTIVITY;
	const afterLastSession = unclaimed.on_last_session_end === LastSessionCleanupModes.AFTER_GRACE;
	if (!afterInactivity && !afterLastSession) return null;
	if (await hasWayBackIn({users: userRepository}, user)) return null;
	if (afterInactivity && inactiveMs >= daysMs(unclaimed.inactive_days)) {
		return DeletionReasons.UNCLAIMED_ACCOUNT_ABANDONED;
	}
	if (!afterLastSession) return null;
	const createdAt = snowflakeToDate(BigInt(user.id)).getTime();
	if (Date.now() - createdAt < AccountCleanupDefaults.MIN_ACCOUNT_AGE_MS) return null;
	const sessions = await userRepository.listAuthSessions(user.id);
	return sessions.length === 0 ? DeletionReasons.UNCLAIMED_ACCOUNT_ABANDONED : null;
}

interface ProcessInactivityDeletionsDeps {
	cleanup: AccountCleanupConfig;
	kvClient: IKVProvider;
	userRepository: UserRepository;
	deletionQueueService: KVAccountDeletionQueueService;
	gatewayService: IGatewayService;
	emailService: IEmailService;
	isEmailEnabled: () => Promise<boolean>;
	activityTracker: KVActivityTracker;
	deletionEligibilityService: UserDeletionEligibilityService;
	userUpdateDeps: PartialUserChangePropagationDeps;
}

export async function processInactivityDeletionsCore(
	deps: ProcessInactivityDeletionsDeps,
): Promise<InactivityCheckResult> {
	const {
		cleanup,
		userRepository,
		deletionQueueService,
		gatewayService,
		emailService,
		isEmailEnabled,
		activityTracker,
		deletionEligibilityService,
		userUpdateDeps,
	} = deps;
	const result: InactivityCheckResult = {
		warningsSent: 0,
		deletionsScheduled: 0,
		suspensionsCleared: 0,
		errors: 0,
	};
	Logger.debug('Starting inactivity deletion check');
	const needsRebuild = await activityTracker.needsRebuild();
	if (needsRebuild) {
		Logger.info('Activity tracker needs rebuild, rebuilding from Cassandra');
		await activityTracker.rebuildActivities();
	}
	const userDeps: ProcessUserDeps = {
		cleanup,
		userRepository,
		deletionQueueService,
		gatewayService,
		emailService,
		isEmailEnabled,
		activityTracker,
		deletionEligibilityService,
		decisionRepository: new EnforcementDecisionRepository(),
		userUpdateDeps,
	};
	let pageState: string | null = null;
	let processedUsers = 0;
	do {
		const page = await userRepository.scanAllUsersPage(BATCH_SIZE, pageState);
		pageState = page.pageState;
		const users = page.users;
		if (users.length === 0) continue;
		const pageActivities = await loadPageActivities(activityTracker, users);
		await mapWithConcurrency(users, USER_PROCESSING_CONCURRENCY, async (user) => {
			try {
				await processUser(user, userDeps, pageActivities, result);
			} catch (userError) {
				Logger.error({error: userError, userId: user.id}, 'Failed to process inactive user');
				result.errors++;
			}
		});
		processedUsers += users.length;
		if (processedUsers % 1000 === 0) {
			Logger.debug(
				{processedUsers, warningsSent: result.warningsSent, deletionsScheduled: result.deletionsScheduled},
				'Inactivity deletion progress',
			);
		}
	} while (pageState);
	Logger.info(
		{
			processedUsers,
			warningsSent: result.warningsSent,
			deletionsScheduled: result.deletionsScheduled,
			suspensionsCleared: result.suspensionsCleared,
			errors: result.errors,
		},
		'Completed inactivity deletion processing',
	);
	return result;
}

const processInactivityDeletions: WorkerTaskHandler = async (_payload, helpers) => {
	helpers.logger.debug('Processing processInactivityDeletions task');
	const {
		kvClient,
		userRepository,
		deletionQueueService,
		gatewayService,
		emailService,
		instanceConfigRepository,
		activityTracker,
		deletionEligibilityService,
		userCacheService,
		guildRepository,
	} = getWorkerDependencies();
	await processInactivityDeletionsCore({
		cleanup: await instanceConfigRepository.getAccountsConfig(),
		kvClient,
		userRepository,
		deletionQueueService,
		gatewayService,
		emailService,
		isEmailEnabled: () => instanceConfigRepository.isEmailEnabled(),
		activityTracker,
		deletionEligibilityService,
		userUpdateDeps: {userCacheService, gatewayService, userRepository, guildRepository},
	});
};

export default processInactivityDeletions;