Skip to content

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

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

import {createGuildID, type GuildID, type UserID} from '@app/api/BrandedTypes';
import {
	ensureActiveGuildTainted,
	type ThreadViewer,
	userViewerActive,
	viewerActive,
} from '@app/api/experiment/ChannelThreadsGate';
import {CHANNEL_THREADS_CLIENT_FEATURE, type ProtectedBitActor} from '@app/api/utils/featureUtils';
import {THREAD_PERMISSIONS} from '@fluxer/constants/src/ThreadPermissionUtils';
import type {ChannelResponse} from '@fluxer/schema/src/domains/channel/ChannelSchemas';
import type {GuildResponse} from '@fluxer/schema/src/domains/guild/GuildResponseSchemas';

export async function resolveProtectedBitActor(params: {
	guildId: GuildID;
	userId: UserID;
	clientFeatures: ReadonlySet<string>;
	viewer?: ThreadViewer;
	isBot: () => Promise<boolean>;
}): Promise<ProtectedBitActor> {
	await ensureActiveGuildTainted(params.guildId);
	return {
		clientFeatures: params.clientFeatures,
		threadBits: {mode: 'active', writer: await threadBitWriter(params)},
	};
}

async function threadBitWriter(params: {
	userId: UserID;
	clientFeatures: ReadonlySet<string>;
	viewer?: ThreadViewer;
	isBot: () => Promise<boolean>;
}): Promise<boolean> {
	if (params.viewer) return userViewerActive(params.viewer);
	if (await params.isBot()) return true;
	return params.clientFeatures.has(CHANNEL_THREADS_CLIENT_FEATURE);
}

export function hasThreadPermissionBits(value: bigint | null | undefined): boolean {
	return value != null && (value & THREAD_PERMISSIONS) !== 0n;
}

export function stripThreadPermissionBits(value: bigint): bigint {
	return value & ~THREAD_PERMISSIONS;
}

export async function shouldMaskThreadPermissionBits(
	guildId: GuildID,
	viewer: ThreadViewer | undefined,
	values: Iterable<bigint | null | undefined>,
): Promise<boolean> {
	if (!viewer || viewer.kind === 'system') return false;
	return [...values].some(hasThreadPermissionBits) && !viewerActive(viewer, guildId);
}

export async function maskChannelResponseThreadBits(
	guildId: GuildID | null | undefined,
	viewer: ThreadViewer | undefined,
	responses: Array<ChannelResponse>,
): Promise<Array<ChannelResponse>> {
	if (!guildId) return responses;
	const values = responses.flatMap((response) =>
		(response.permission_overwrites ?? []).flatMap((overwrite) => [BigInt(overwrite.allow), BigInt(overwrite.deny)]),
	);
	if (!(await shouldMaskThreadPermissionBits(guildId, viewer, values))) return responses;
	return responses.map((response) =>
		response.permission_overwrites
			? {
					...response,
					permission_overwrites: response.permission_overwrites.map((overwrite) => ({
						...overwrite,
						allow: stripThreadPermissionBits(BigInt(overwrite.allow)).toString(),
						deny: stripThreadPermissionBits(BigInt(overwrite.deny)).toString(),
					})),
				}
			: response,
	);
}

export async function maskGuildResponseThreadBits(
	guildId: GuildID,
	viewer: ThreadViewer,
	guild: GuildResponse,
): Promise<GuildResponse> {
	if (!guild.roles) return guild;
	const values = guild.roles.map((role) => BigInt(role.permissions));
	if (!(await shouldMaskThreadPermissionBits(guildId, viewer, values))) return guild;
	return {
		...guild,
		roles: guild.roles.map((role) => ({
			...role,
			permissions: stripThreadPermissionBits(BigInt(role.permissions)).toString(),
		})),
	};
}

export async function maskUserGuildsThreadBits(
	viewer: ThreadViewer,
	guilds: Array<GuildResponse>,
): Promise<Array<GuildResponse>> {
	return Promise.all(
		guilds.map(async (guild) => {
			if (guild.permissions == null) return guild;
			const permissions = BigInt(guild.permissions);
			if (!(await shouldMaskThreadPermissionBits(createGuildID(BigInt(guild.id)), viewer, [permissions]))) return guild;
			return {...guild, permissions: stripThreadPermissionBits(permissions).toString()};
		}),
	);
}

export function flagThreadActiveUserGuilds(viewer: ThreadViewer, guilds: Array<GuildResponse>): Array<GuildResponse> {
	if (!userViewerActive(viewer)) return guilds;
	return guilds.map((guild) => ({...guild, threads_active: true}));
}