Skip to content

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

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

import assert from 'node:assert/strict';
import {randomUUID} from 'node:crypto';
import {AdminArchive} from '@app/api/admin/models/AdminArchiveModel';
import {ArchiveAttemptSupersededError} from '@app/api/archive/ArchiveAttemptSupersededError';
import {BatchBuilder, executeConditional, fetchMany, fetchOne} from '@app/api/database/CassandraQueryExecution';
import {Db, type DbOp} from '@app/api/database/CassandraTypes';
import {
	ADMIN_ARCHIVE_INDEX_COLUMNS,
	type AdminArchiveIndexRow,
	type AdminArchiveRow,
} from '@app/api/database/types/AdminArchiveTypes';
import {Logger} from '@app/api/Logger';
import {AdminArchivesByRequester, AdminArchivesBySubject, AdminArchivesByType} from '@app/api/Tables';
import {mapWithConcurrency} from '@app/api/utils/ConcurrencyUtils';
import type {ArchiveSubjectType} from '@fluxer/schema/src/domains/admin/AdminArchiveSchemas';
import {ms} from 'itty-time';

const RETENTION_DAYS = 365;
const DEFAULT_RETENTION_MS = ms(`${RETENTION_DAYS} days`);
const ARCHIVE_READ_CONCURRENCY = 10;

interface AdminArchivePatch {
	completed_at?: DbOp<Date>;
	failed_at?: DbOp<Date>;
	terminal_failed_at?: DbOp<Date>;
	storage_key?: DbOp<string>;
	file_size?: DbOp<bigint>;
	progress_percent?: DbOp<number>;
	progress_step?: DbOp<string>;
	error_message?: DbOp<string>;
	download_url_expires_at?: DbOp<Date>;
}

function computeTtlSeconds(expiresAt: Date | null): number {
	if (expiresAt === null || !Number.isFinite(expiresAt.getTime())) {
		throw new Error('Admin archive has no valid expiry');
	}
	const ttlSeconds = Math.floor((expiresAt.getTime() - Date.now()) / 1000);
	if (ttlSeconds < 1) throw new Error('Admin archive has expired');
	return ttlSeconds;
}

function filterExpired(rows: Array<AdminArchiveRow>, includeExpired: boolean): Array<AdminArchiveRow> {
	if (includeExpired) return rows;
	const now = Date.now();
	return rows.filter((row) => !row.expires_at || row.expires_at.getTime() > now);
}

export class AdminArchiveRepository {
	async create(archive: AdminArchive): Promise<void> {
		archive.expiresAt ??= new Date(archive.requestedAt.getTime() + DEFAULT_RETENTION_MS);
		const row = archive.toRow();
		const applied = await executeConditional(
			AdminArchivesBySubject.insertIfNotExistsWithTtl(row, computeTtlSeconds(row.expires_at)),
		);
		if (!applied) {
			throw new Error(`Admin archive ${row.archive_id} for ${row.subject_type} ${row.subject_id} already exists`);
		}
		const indexRow: AdminArchiveIndexRow = {
			subject_type: row.subject_type,
			subject_id: row.subject_id,
			archive_id: row.archive_id,
			requested_by: row.requested_by,
		};
		const ttlSeconds = computeTtlSeconds(row.expires_at);
		const batch = new BatchBuilder();
		batch.addPrepared(AdminArchivesByRequester.insertWithTtl(indexRow, ttlSeconds));
		batch.addPrepared(AdminArchivesByType.insertWithTtl(indexRow, ttlSeconds));
		await batch.execute();
		Logger.debug(
			{subjectType: archive.subjectType, subjectId: archive.subjectId, archiveId: archive.archiveId},
			'Created admin archive record',
		);
	}

	private async patchOwned(archive: AdminArchive, patch: AdminArchivePatch): Promise<void> {
		assert(archive.attemptId !== null, 'Admin archive mutation requires a claimed attempt');
		const applied = await executeConditional(
			AdminArchivesBySubject.conditionalPatchByPkWithTtl(
				{
					subject_type: archive.subjectType,
					subject_id: archive.subjectId,
					archive_id: archive.archiveId,
				},
				patch,
				{
					requested_at: archive.requestedAt,
					attempt_id: archive.attemptId,
					completed_at: null,
					failed_at: null,
					terminal_failed_at: null,
				},
				computeTtlSeconds(archive.expiresAt),
			),
		);
		if (!applied) throw new ArchiveAttemptSupersededError();
	}

	private async hydrateIndexRows(
		rows: ReadonlyArray<AdminArchiveIndexRow>,
		includeExpired: boolean,
	): Promise<Array<AdminArchive>> {
		const archives = await mapWithConcurrency(rows, ARCHIVE_READ_CONCURRENCY, (row) =>
			this.findBySubjectAndArchiveId(row.subject_type, row.subject_id, row.archive_id),
		);
		const now = Date.now();
		return archives.filter(
			(archive): archive is AdminArchive =>
				archive !== null && (includeExpired || archive.expiresAt === null || archive.expiresAt.getTime() > now),
		);
	}

	async markAsStarted(archive: AdminArchive, progressStep = 'Starting archive'): Promise<AdminArchive> {
		const attempt = new AdminArchive({
			...archive.toRow(),
			attempt_id: randomUUID(),
			started_at: new Date(),
			failed_at: null,
			error_message: null,
			progress_percent: 0,
			progress_step: progressStep,
		});
		const applied = await executeConditional(
			AdminArchivesBySubject.conditionalPatchByPkWithTtl(
				{
					subject_type: archive.subjectType,
					subject_id: archive.subjectId,
					archive_id: archive.archiveId,
				},
				{
					attempt_id: Db.set(attempt.attemptId),
					started_at: Db.set(attempt.startedAt),
					failed_at: Db.clear(),
					error_message: Db.clear(),
					progress_percent: Db.set(0),
					progress_step: Db.set(progressStep),
				},
				{
					requested_at: archive.requestedAt,
					attempt_id: archive.attemptId,
					completed_at: null,
					terminal_failed_at: null,
				},
				computeTtlSeconds(archive.expiresAt),
			),
		);
		if (!applied) throw new ArchiveAttemptSupersededError();
		return attempt;
	}

	async updateProgress(archive: AdminArchive, progressPercent: number, progressStep: string): Promise<void> {
		await this.patchOwned(archive, {
			progress_percent: Db.set(progressPercent),
			progress_step: Db.set(progressStep),
		});
		Logger.debug({archiveId: archive.archiveId, progressPercent, progressStep}, 'Updated admin archive progress');
	}

	async markAsCompleted(
		archive: AdminArchive,
		storageKey: string,
		fileSize: bigint,
		downloadUrlExpiresAt: Date,
	): Promise<void> {
		await this.patchOwned(archive, {
			completed_at: Db.set(new Date()),
			failed_at: Db.clear(),
			error_message: Db.clear(),
			storage_key: Db.set(storageKey),
			file_size: Db.set(fileSize),
			download_url_expires_at: Db.set(downloadUrlExpiresAt),
			progress_percent: Db.set(100),
			progress_step: Db.set('Completed'),
		});
	}

	async markAsFailed(archive: AdminArchive, errorMessage: string): Promise<void> {
		await this.patchOwned(archive, {
			failed_at: Db.set(new Date()),
			error_message: Db.set(errorMessage),
			progress_step: Db.set('Failed'),
		});
	}

	async markAsTerminallyFailed(archive: AdminArchive, errorMessage: string): Promise<void> {
		const failedAt = new Date();
		await this.patchOwned(archive, {
			failed_at: Db.set(failedAt),
			terminal_failed_at: Db.set(failedAt),
			error_message: Db.set(errorMessage),
			progress_step: Db.set('Failed'),
		});
	}

	async findBySubjectAndArchiveId(
		subjectType: ArchiveSubjectType,
		subjectId: bigint,
		archiveId: bigint,
	): Promise<AdminArchive | null> {
		const query = AdminArchivesBySubject.select({
			where: [
				AdminArchivesBySubject.where.eq('subject_type'),
				AdminArchivesBySubject.where.eq('subject_id'),
				AdminArchivesBySubject.where.eq('archive_id'),
			],
			limit: 1,
		});
		const row = await fetchOne<AdminArchiveRow>(
			query.bind({
				subject_type: subjectType,
				subject_id: subjectId,
				archive_id: archiveId,
			}),
		);
		return row ? new AdminArchive(row) : null;
	}

	async listBySubject(
		subjectType: ArchiveSubjectType,
		subjectId: bigint,
		limit = 20,
		includeExpired = false,
	): Promise<Array<AdminArchive>> {
		const query = AdminArchivesBySubject.select({
			where: [AdminArchivesBySubject.where.eq('subject_type'), AdminArchivesBySubject.where.eq('subject_id')],
			limit,
		});
		const rows = await fetchMany<AdminArchiveRow>(
			query.bind({
				subject_type: subjectType,
				subject_id: subjectId,
			}),
		);
		return filterExpired(rows, includeExpired).map((row) => new AdminArchive(row));
	}

	async listByType(subjectType: ArchiveSubjectType, limit = 50, includeExpired = false): Promise<Array<AdminArchive>> {
		const query = AdminArchivesByType.select({
			columns: ADMIN_ARCHIVE_INDEX_COLUMNS,
			where: AdminArchivesByType.where.eq('subject_type'),
			limit,
		});
		const rows = await fetchMany<AdminArchiveIndexRow>(
			query.bind({
				subject_type: subjectType,
			}),
		);
		return this.hydrateIndexRows(rows, includeExpired);
	}

	async listByRequester(requestedBy: bigint, limit = 50, includeExpired = false): Promise<Array<AdminArchive>> {
		const query = AdminArchivesByRequester.select({
			columns: ADMIN_ARCHIVE_INDEX_COLUMNS,
			where: AdminArchivesByRequester.where.eq('requested_by'),
			limit,
		});
		const rows = await fetchMany<AdminArchiveIndexRow>(
			query.bind({
				requested_by: requestedBy,
			}),
		);
		return this.hydrateIndexRows(rows, includeExpired);
	}
}