Skip to content

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

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

import type {UserID} from '@app/api/BrandedTypes';
import {Config} from '@app/api/Config';
import type {
	OperatorPassWallDecisionRow,
	OperatorPassWallEntryRow,
	OperatorPassWallEventRow,
	OperatorPassWallRevisionRow,
	OperatorPassWallRevisionStatus,
} from '@app/api/database/types/OperatorPassTypes';
import type {OperatorPassRepository} from '@app/api/operator_pass/OperatorPassRepository';
import {OPERATOR_PASS_WALL_FALLBACK_NAME} from '@app/api/operator_pass/OperatorPassWallConstants';
import type {OperatorPassWallEntryStore} from '@app/api/operator_pass/OperatorPassWallEntryStore';
import {
	type OperatorPassWallAsOfEntry,
	reconstructOperatorPassWallEntry,
	revisionStatuses,
} from '@app/api/operator_pass/OperatorPassWallHistory';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {UserFlags} from '@fluxer/constants/src/UserConstants';
import {compareSnowflakes} from '@fluxer/snowflake/src/SnowflakeComparison';

const AS_OF_BATCH_SIZE = 25;

interface OperatorPassWallTimelineRevision {
	revision: OperatorPassWallRevisionRow;
	status: OperatorPassWallRevisionStatus;
	decision: OperatorPassWallDecisionRow | null;
}

interface OperatorPassWallTimeline {
	entry: OperatorPassWallEntryRow | null;
	revisions: Array<OperatorPassWallTimelineRevision>;
	decisions: Array<OperatorPassWallDecisionRow>;
	events: Array<OperatorPassWallEventRow>;
}

export class OperatorPassWallHistoryService {
	constructor(
		private readonly repository: OperatorPassRepository,
		private readonly userRepository: UserRepository,
		private readonly entries: OperatorPassWallEntryStore,
	) {}

	async timeline(userId: UserID): Promise<OperatorPassWallTimeline> {
		const [entry, revisions, decisions, events] = await Promise.all([
			this.repository.findWallEntry(userId),
			this.repository.listWallRevisions(userId),
			this.repository.listWallDecisions(userId),
			this.repository.listWallEvents(userId),
		]);
		const statuses = revisionStatuses(revisions, decisions);
		return {
			entry,
			revisions: revisions.map((revision) => ({
				revision,
				status: statuses.get(revision.revision_id)?.status ?? 'pending',
				decision: statuses.get(revision.revision_id)?.decision ?? null,
			})),
			decisions,
			events,
		};
	}

	async wallAsOf(at: Date): Promise<Array<OperatorPassWallAsOfEntry>> {
		const result: Array<OperatorPassWallAsOfEntry> = [];
		const entries = await this.entries.scanAll();
		for (let index = 0; index < entries.length; index += AS_OF_BATCH_SIZE) {
			const items = await Promise.all(
				entries.slice(index, index + AS_OF_BATCH_SIZE).map(async (entry) => {
					const [revisions, decisions, events, user] = await Promise.all([
						this.repository.listWallRevisions(entry.user_id),
						this.repository.listWallDecisions(entry.user_id),
						this.repository.listWallEvents(entry.user_id),
						this.userRepository.findUnique(entry.user_id),
					]);
					return reconstructOperatorPassWallEntry({
						userId: entry.user_id,
						at,
						revisions,
						decisions,
						events,
						tierMinimums: Config.operatorPass.wallTierMinimums,
						userDeleted: !user || (user.flags & UserFlags.DELETED) !== 0n,
					});
				}),
			);
			for (const item of items) {
				if (item) result.push(item);
			}
		}
		for (const tombstone of await this.repository.listWallTombstones()) {
			const tokenId = tombstone.token_ as UserID;
			const item = reconstructOperatorPassWallEntry({
				userId: tokenId,
				at,
				revisions: [],
				decisions: [],
				events: await this.repository.listWallEvents(tokenId),
				tierMinimums: Config.operatorPass.wallTierMinimums,
			});
			if (item) result.push({...item, name: OPERATOR_PASS_WALL_FALLBACK_NAME, avatar: null, deleted: true});
		}
		result.sort(
			(left, right) =>
				right.tier - left.tier ||
				left.firstPassAt.getTime() - right.firstPassAt.getTime() ||
				compareSnowflakes(left.userId, right.userId),
		);
		return result;
	}
}