Skip to content

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

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

import type {ChannelID, GuildID, MessageID, UserID} from '@app/api/BrandedTypes';
import type {ChannelRepository} from '@app/api/channel/ChannelRepository';
import {mapThreadMemberToRpcResponse, mapThreadToRpcResponse} from '@app/api/channel/services/thread/ThreadMappers';
import {mapThreadParentFields} from '@app/api/channel/services/thread/ThreadParentSettings';
import {loadThreadViews} from '@app/api/channel/services/thread/ThreadViews';
import {getChannelThreadsConfig, isTainted} from '@app/api/experiment/ChannelThreadsGate';
import type {Channel} from '@app/api/models/Channel';
import type {ThreadMember} from '@app/api/models/ThreadMember';
import type {ThreadParentConfig} from '@app/api/models/ThreadParentConfig';
import {mapWithConcurrency} from '@app/api/utils/ConcurrencyUtils';
import {
	FORUM_UNREAD_COUNT_CAP,
	MAX_THREAD_MEMBERS,
	THREAD_ONLY_CHANNEL_TYPES,
} from '@fluxer/constants/src/ThreadConstants';
import type {
	ThreadMemberRpcResponse,
	ThreadParentSettingsRpcResponse,
} from '@fluxer/schema/src/domains/channel/ThreadSchemas';

const MEMBER_PAGE_SIZE = 1000;
const MEMBER_LOAD_CONCURRENCY = 16;

export type ThreadGateRpcData = {thread_gate: {active: boolean; config_version: number}; thread_tainted: boolean};

export interface ThreadCollectionRpcData {
	threads: Array<ReturnType<typeof mapThreadToRpcResponse>>;
	thread_members?: Array<ThreadMemberRpcResponse>;
	thread_parent_settings: Array<ThreadParentSettingsRpcResponse>;
}

export async function resolveThreadGateRpcData(guildId: GuildID): Promise<ThreadGateRpcData | null> {
	return {
		thread_gate: {active: true, config_version: getChannelThreadsConfig().config_version},
		thread_tainted: await isTainted(guildId),
	};
}

function mapParentSettingsToRpc(
	parent: Channel,
	config: ThreadParentConfig | null,
): ThreadParentSettingsRpcResponse | null {
	if (config === null && !THREAD_ONLY_CHANNEL_TYPES.has(parent.type)) return null;
	return {channel_id: parent.id.toString(), ...mapThreadParentFields(parent.type, config)};
}

async function listAllMembers(repository: ChannelRepository, threadId: ChannelID): Promise<Array<ThreadMember>> {
	const members: Array<ThreadMember> = [];
	let after: UserID | undefined;
	while (members.length < MAX_THREAD_MEMBERS * 2) {
		const page = await repository.threads.listMembers(threadId, {after, limit: MEMBER_PAGE_SIZE});
		members.push(...page);
		if (page.length < MEMBER_PAGE_SIZE) break;
		after = page[page.length - 1]!.userId;
	}
	return members;
}

export async function loadThreadCollectionRpcData(
	repository: ChannelRepository,
	guildId: GuildID,
	parents: ReadonlyArray<Channel>,
	{members: includeMembers}: {members: boolean},
): Promise<ThreadCollectionRpcData> {
	const [states, parentConfigs] = await Promise.all([
		repository.threads.listActiveThreads(guildId),
		repository.threads.listParentConfigs(guildId),
	]);
	const views = await loadThreadViews(repository, states, parents);
	const members = includeMembers
		? await mapWithConcurrency(views, MEMBER_LOAD_CONCURRENCY, (view) =>
				listAllMembers(repository, view.state.threadId),
			)
		: null;
	const configs = new Map(parentConfigs.map((config) => [config.channelId, config]));
	return {
		threads: views.map(mapThreadToRpcResponse),
		...(members ? {thread_members: members.flat().map(mapThreadMemberToRpcResponse)} : {}),
		thread_parent_settings: parents.flatMap((parent) => {
			const settings = mapParentSettingsToRpc(parent, configs.get(parent.id) ?? null);
			return settings ? [settings] : [];
		}),
	};
}

export async function listThreadMembersPage(
	repository: ChannelRepository,
	params: {guildId: GuildID; threadIds: Array<ChannelID>; limit: number; after?: UserID},
): Promise<{
	members: Array<ThreadMemberRpcResponse>;
	has_more: boolean;
	next_thread_id: string | null;
	next_after_user_id: string | null;
}> {
	const states = await repository.threads.getStates(params.threadIds);
	const inGuild = new Set(states.filter((state) => state.guildId === params.guildId).map((state) => state.threadId));
	const members: Array<ThreadMember> = [];
	let after = params.after;
	for (const threadId of params.threadIds) {
		const cursor = after;
		after = undefined;
		if (!inGuild.has(threadId)) continue;
		const remaining = params.limit - members.length;
		const page = await repository.threads.listMembers(threadId, {after: cursor, limit: remaining + 1});
		if (page.length > remaining) {
			members.push(...page.slice(0, remaining));
			return {
				members: members.map(mapThreadMemberToRpcResponse),
				has_more: true,
				next_thread_id: threadId.toString(),
				next_after_user_id: remaining > 0 ? page[remaining - 1]!.userId.toString() : null,
			};
		}
		members.push(...page);
	}
	return {
		members: members.map(mapThreadMemberToRpcResponse),
		has_more: false,
		next_thread_id: null,
		next_after_user_id: null,
	};
}

export interface ForumUnreadRpcEntry {
	thread_id: string;
	count?: number;
	missing?: true;
}

export async function loadForumUnreads(
	repository: ChannelRepository,
	params: {
		guildId: GuildID;
		channelId: ChannelID;
		threads: Array<{threadId: ChannelID; ackMessageId?: MessageID}>;
	},
): Promise<Array<ForumUnreadRpcEntry>> {
	const states = await repository.threads.getStates(params.threads.map((thread) => thread.threadId));
	const inForum = new Set(
		states
			.filter((state) => state.guildId === params.guildId && state.parentId === params.channelId)
			.map((state) => state.threadId),
	);
	return Promise.all(
		params.threads
			.filter((thread) => inForum.has(thread.threadId))
			.map(async ({threadId, ackMessageId}): Promise<ForumUnreadRpcEntry> => {
				if (ackMessageId === undefined) return {thread_id: threadId.toString(), missing: true};
				const unread = await repository.messages.listMessages(
					threadId,
					undefined,
					FORUM_UNREAD_COUNT_CAP,
					ackMessageId,
				);
				return {thread_id: threadId.toString(), count: unread.length};
			}),
	);
}