Skip to content

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

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

import {createTestAccount} from '@app/api/auth/tests/AuthTestUtils';
import {createChannelID, createGuildID, createRoleID} from '@app/api/BrandedTypes';
import {authorizeBot, createTestBotAccount} from '@app/api/bot/tests/BotTestUtils';
import {ChannelRepository} from '@app/api/channel/ChannelRepository';
import {fetchMany, fetchOne} from '@app/api/database/CassandraQueryExecution';
import type {GuildThreadStateRow} from '@app/api/database/types/ThreadTypes';
import {clearChannelThreadsTaintCacheForTesting} from '@app/api/experiment/ChannelThreadsGate';
import {
	acceptInvite,
	addMemberRole,
	createChannelInvite,
	createGuild,
	createRole,
	getChannel,
} from '@app/api/guild/tests/GuildTestUtils';
import {GuildThreadState, ThreadOnlyChannelsByGuild} from '@app/api/Tables';
import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
import {createBuilder} from '@app/api/test/TestRequestBuilder';
import {ChannelTypes, DEFAULT_PERMISSIONS, Permissions} from '@fluxer/constants/src/ChannelConstants';
import {
	DEFAULT_THREAD_PERMISSIONS,
	THREAD_PERMISSIONS,
	ThreadPermissionFlags,
} 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';
import type {GuildRoleResponse} from '@fluxer/schema/src/domains/guild/GuildRoleSchemas';
import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, test} from 'vitest';

const FEATURES = 'X-Fluxer-Features';
const CAPABLE = 'channel_threads';
const FETCH_MARKER = GuildThreadState.selectCql({where: GuildThreadState.where.eq('guild_id'), limit: 1});

function bits(value: string | undefined): bigint {
	return BigInt(value ?? '0');
}

describe('thread permission bits across guild modes', () => {
	let harness: ApiTestHarness;

	beforeAll(async () => {
		harness = await createApiTestHarness();
	});

	beforeEach(async () => {
		await harness.reset();
		clearChannelThreadsTaintCacheForTesting();
	});

	afterEach(() => {
		clearChannelThreadsTaintCacheForTesting();
	});

	afterAll(async () => {
		await harness?.shutdown();
	});

	async function listRoles(token: string, guildId: string, capable: boolean): Promise<Array<GuildRoleResponse>> {
		const builder = createBuilder<Array<GuildRoleResponse>>(harness, token).get(`/guilds/${guildId}/roles`);
		return (capable ? builder.header(FEATURES, CAPABLE) : builder).execute();
	}

	async function roleBits(token: string, guildId: string, roleId: string): Promise<bigint> {
		const roles = await listRoles(token, guildId, true);
		return bits(roles.find((role) => role.id === roleId)?.permissions);
	}

	test('active guilds seed @everyone, write bits for capable users and restore them for others', async () => {
		const owner = await createTestAccount(harness);
		const guild = await createGuild(harness, owner.token, 'Active');
		expect(await roleBits(owner.token, guild.id, guild.id)).toBe(DEFAULT_PERMISSIONS | DEFAULT_THREAD_PERMISSIONS);
		const marker = await fetchOne<GuildThreadStateRow>(FETCH_MARKER, {guild_id: createGuildID(BigInt(guild.id))});
		expect(marker?.perms_seeded_at).toBeInstanceOf(Date);
		const role = await createBuilder<GuildRoleResponse>(harness, owner.token)
			.post(`/guilds/${guild.id}/roles`)
			.header(FEATURES, CAPABLE)
			.body({name: 'mods', permissions: (Permissions.SEND_MESSAGES | ThreadPermissionFlags.MANAGE_THREADS).toString()})
			.execute();
		expect(bits(role.permissions)).toBe(Permissions.SEND_MESSAGES | ThreadPermissionFlags.MANAGE_THREADS);
		const legacy = await createBuilder<GuildRoleResponse>(harness, owner.token)
			.patch(`/guilds/${guild.id}/roles/${role.id}`)
			.body({permissions: (Permissions.VIEW_CHANNEL | ThreadPermissionFlags.CREATE_PUBLIC_THREADS).toString()})
			.execute();
		expect(bits(legacy.permissions) & THREAD_PERMISSIONS).toBe(0n);
		expect(await roleBits(owner.token, guild.id, role.id)).toBe(
			Permissions.VIEW_CHANNEL | ThreadPermissionFlags.MANAGE_THREADS,
		);
		const masked = await listRoles(owner.token, guild.id, false);
		expect(masked.every((r) => (bits(r.permissions) & THREAD_PERMISSIONS) === 0n)).toBe(true);
		const cleared = await createBuilder<GuildRoleResponse>(harness, owner.token)
			.patch(`/guilds/${guild.id}/roles/${role.id}`)
			.header(FEATURES, CAPABLE)
			.body({permissions: Permissions.VIEW_CHANNEL.toString()})
			.execute();
		expect(bits(cleared.permissions)).toBe(Permissions.VIEW_CHANNEL);
	});

	test('bots write thread bits and bot invites keep them only for capable active users in active guilds', async () => {
		const owner = await createTestAccount(harness);
		const guild = await createGuild(harness, owner.token, 'Bots');
		const bot = await createTestBotAccount(harness);
		const requested =
			Permissions.MANAGE_ROLES | Permissions.SEND_MESSAGES | ThreadPermissionFlags.SEND_MESSAGES_IN_THREADS;
		await createBuilder<{redirect_to: string}>(harness, owner.token)
			.post('/oauth2/authorize/consent')
			.header(FEATURES, CAPABLE)
			.body({client_id: bot.appId, scope: 'bot', guild_id: guild.id, permissions: requested.toString()})
			.execute();
		const botRole = (await listRoles(owner.token, guild.id, true)).find((role) => role.name !== '@everyone');
		expect(bits(botRole?.permissions)).toBe(requested);
		const legacyBot = await createTestBotAccount(harness);
		await authorizeBot(harness, owner.token, legacyBot.appId, ['bot'], guild.id, requested.toString());
		const legacyRole = (await listRoles(owner.token, guild.id, true)).find(
			(role) => role.name !== '@everyone' && role.id !== botRole?.id,
		);
		expect(bits(legacyRole?.permissions)).toBe(Permissions.MANAGE_ROLES | Permissions.SEND_MESSAGES);
		const written = await createBuilder<GuildRoleResponse>(harness, `Bot ${bot.botToken}`)
			.post(`/guilds/${guild.id}/roles`)
			.body({name: 'bot-made', permissions: ThreadPermissionFlags.SEND_MESSAGES_IN_THREADS.toString()})
			.execute();
		expect(bits(written.permissions)).toBe(ThreadPermissionFlags.SEND_MESSAGES_IN_THREADS);
		const vcm = await createBuilder<GuildRoleResponse>(harness, `Bot ${bot.botToken}`)
			.post(`/guilds/${guild.id}/roles`)
			.body({name: 'bot-vcm', permissions: Permissions.VIEW_CHANNEL_MEMBERS.toString()})
			.execute();
		expect(bits(vcm.permissions)).toBe(0n);
	});

	test('active channel creates store thread-aware overwrites and mask them for non-viewers', async () => {
		const owner = await createTestAccount(harness);
		const guild = await createGuild(harness, owner.token, 'Overwrites');
		const allow = Permissions.SEND_MESSAGES | ThreadPermissionFlags.SEND_MESSAGES_IN_THREADS;
		const channel = await createBuilder<ChannelResponse>(harness, owner.token)
			.post(`/guilds/${guild.id}/channels`)
			.header(FEATURES, CAPABLE)
			.body({
				name: 'active-overwrites',
				type: ChannelTypes.GUILD_TEXT,
				permission_overwrites: [{id: guild.id, type: 0, allow: allow.toString(), deny: '0'}],
			})
			.execute();
		expect(channel.permission_overwrites?.map((overwrite) => bits(overwrite.allow))).toEqual([allow]);
		const viewerList = await createBuilder<Array<ChannelResponse>>(harness, owner.token)
			.get(`/guilds/${guild.id}/channels`)
			.header(FEATURES, CAPABLE)
			.execute();
		const legacyList = await createBuilder<Array<ChannelResponse>>(harness, owner.token)
			.get(`/guilds/${guild.id}/channels`)
			.execute();
		const pick = (list: Array<ChannelResponse>) =>
			bits(list.find((entry) => entry.id === channel.id)?.permission_overwrites?.[0]?.allow);
		expect(pick(viewerList)).toBe(allow);
		expect(pick(legacyList)).toBe(Permissions.SEND_MESSAGES);
		const single = async (capable: boolean) => {
			const builder = createBuilder<ChannelResponse>(harness, owner.token).get(`/channels/${channel.id}`);
			return bits(
				(await (capable ? builder.header(FEATURES, CAPABLE) : builder).execute()).permission_overwrites?.[0]?.allow,
			);
		};
		expect(await single(true)).toBe(allow);
		expect(await single(false)).toBe(Permissions.SEND_MESSAGES);
		const patched = await createBuilder<ChannelResponse>(harness, owner.token)
			.patch(`/channels/${channel.id}`)
			.body({topic: 'masked'})
			.execute();
		expect(bits(patched.permission_overwrites?.[0]?.allow)).toBe(Permissions.SEND_MESSAGES);
	});

	test('overwrite removals keep thread bits the actor cannot write, without escalation errors', async () => {
		const owner = await createTestAccount(harness);
		const member = await createTestAccount(harness);
		const guild = await createGuild(harness, owner.token, 'Removals');
		const target = await createRole(harness, owner.token, guild.id, {name: 'target', permissions: '0'});
		const mod = await createRole(harness, owner.token, guild.id, {
			name: 'mod',
			permissions: (Permissions.MANAGE_ROLES | Permissions.MANAGE_CHANNELS).toString(),
		});
		const systemChannel = await getChannel(harness, owner.token, guild.system_channel_id!);
		const invite = await createChannelInvite(harness, owner.token, systemChannel.id);
		await acceptInvite(harness, member.token, invite.code);
		await addMemberRole(harness, owner.token, guild.id, member.userId, mod.id);
		const inThreads = ThreadPermissionFlags.SEND_MESSAGES_IN_THREADS;
		const manageThreads = ThreadPermissionFlags.MANAGE_THREADS;
		const channel = await createBuilder<ChannelResponse>(harness, owner.token)
			.post(`/guilds/${guild.id}/channels`)
			.header(FEATURES, CAPABLE)
			.body({
				name: 'removals',
				type: ChannelTypes.GUILD_TEXT,
				permission_overwrites: [
					{id: guild.id, type: 0, allow: (Permissions.SEND_MESSAGES | inThreads).toString(), deny: '0'},
					{id: target.id, type: 0, allow: '0', deny: (Permissions.ADD_REACTIONS | manageThreads).toString()},
				],
			})
			.execute();
		const channelId = createChannelID(BigInt(channel.id));
		const stored = async () => {
			const overwrites = (await new ChannelRepository().channelData.findUnique(channelId))!.permissionOverwrites;
			return {
				everyone: overwrites.get(createRoleID(BigInt(guild.id))),
				target: overwrites.get(createRoleID(BigInt(target.id))),
			};
		};
		await createBuilder(harness, owner.token)
			.patch(`/channels/${channel.id}`)
			.body({permission_overwrites: []})
			.execute();
		const after = await stored();
		expect([after.everyone?.allow, after.everyone?.deny]).toEqual([inThreads, 0n]);
		expect([after.target?.allow, after.target?.deny]).toEqual([0n, manageThreads]);
	});

	test('deleting a forum removes its thread-only index row', async () => {
		const owner = await createTestAccount(harness);
		const guild = await createGuild(harness, owner.token, 'Forum delete');
		const guildId = createGuildID(BigInt(guild.id));
		const text = await createBuilder<ChannelResponse>(harness, owner.token)
			.post(`/guilds/${guild.id}/channels`)
			.body({name: 'seed', type: ChannelTypes.GUILD_TEXT})
			.execute();
		const repository = new ChannelRepository();
		const source = (await repository.channelData.findUnique(createChannelID(BigInt(text.id))))!;
		const forumId = createChannelID(BigInt(text.id) + 1n);
		await repository.channelData.upsert({
			...source.toRow(),
			channel_id: forumId,
			type: ChannelTypes.GUILD_FORUM,
			name: 'forum',
		});
		const indexRows = () =>
			fetchMany<{channel_id: bigint}>(
				ThreadOnlyChannelsByGuild.selectCql({where: ThreadOnlyChannelsByGuild.where.eq('guild_id')}),
				{guild_id: guildId},
			);
		expect((await indexRows()).some((row) => row.channel_id === forumId)).toBe(true);
		await createBuilder(harness, owner.token)
			.delete(`/channels/${forumId}`)
			.header(FEATURES, CAPABLE)
			.expect(204)
			.execute();
		expect((await indexRows()).some((row) => row.channel_id === forumId)).toBe(false);
	});
	test('channel overwrite edits keep thread bits for clients that cannot write them', async () => {
		const owner = await createTestAccount(harness);
		const guild = await createGuild(harness, owner.token, 'Overwrite edits');
		const inThreads = ThreadPermissionFlags.SEND_MESSAGES_IN_THREADS;
		const channel = await createBuilder<ChannelResponse>(harness, owner.token)
			.post(`/guilds/${guild.id}/channels`)
			.header(FEATURES, CAPABLE)
			.body({
				name: 'edits',
				type: ChannelTypes.GUILD_TEXT,
				permission_overwrites: [
					{id: guild.id, type: 0, allow: (Permissions.SEND_MESSAGES | inThreads).toString(), deny: '0'},
				],
			})
			.execute();
		const channelId = createChannelID(BigInt(channel.id));
		const everyoneId = createRoleID(BigInt(guild.id));
		const storedAllow = async () =>
			(await new ChannelRepository().channelData.findUnique(channelId))?.permissionOverwrites.get(everyoneId)?.allow;
		await createBuilder(harness, owner.token)
			.patch(`/channels/${channel.id}`)
			.body({permission_overwrites: [{id: guild.id, type: 0, allow: Permissions.VIEW_CHANNEL.toString(), deny: '0'}]})
			.execute();
		expect(await storedAllow()).toBe(Permissions.VIEW_CHANNEL | inThreads);
		await createBuilder(harness, owner.token)
			.put(`/channels/${channel.id}/permissions/${guild.id}`)
			.body({type: 0, allow: Permissions.SEND_MESSAGES.toString(), deny: '0'})
			.expect(204)
			.execute();
		expect(await storedAllow()).toBe(Permissions.SEND_MESSAGES | inThreads);
		await createBuilder(harness, owner.token)
			.delete(`/channels/${channel.id}/permissions/${guild.id}`)
			.expect(204)
			.execute();
		expect(await storedAllow()).toBe(inThreads);
		await createBuilder(harness, owner.token)
			.delete(`/channels/${channel.id}/permissions/${guild.id}`)
			.header(FEATURES, CAPABLE)
			.expect(204)
			.execute();
		expect(await storedAllow()).toBeUndefined();
	});
	test('lock_permissions moves copy parent thread bits only for writers', async () => {
		const owner = await createTestAccount(harness);
		const guild = await createGuild(harness, owner.token, 'Lock sync');
		const inThreads = ThreadPermissionFlags.SEND_MESSAGES_IN_THREADS;
		const category = await createBuilder<ChannelResponse>(harness, owner.token)
			.post(`/guilds/${guild.id}/channels`)
			.header(FEATURES, CAPABLE)
			.body({
				name: 'locked',
				type: ChannelTypes.GUILD_CATEGORY,
				permission_overwrites: [
					{id: guild.id, type: 0, allow: (Permissions.SEND_MESSAGES | inThreads).toString(), deny: '0'},
				],
			})
			.execute();
		const everyoneId = createRoleID(BigInt(guild.id));
		const moveAndRead = async (capable: boolean) => {
			const child = await createBuilder<ChannelResponse>(harness, owner.token)
				.post(`/guilds/${guild.id}/channels`)
				.body({name: capable ? 'capable' : 'legacy', type: ChannelTypes.GUILD_TEXT})
				.execute();
			const builder = createBuilder(harness, owner.token)
				.patch(`/guilds/${guild.id}/channels`)
				.body([{id: child.id, parent_id: category.id, lock_permissions: true}])
				.expect(204);
			await (capable ? builder.header(FEATURES, CAPABLE) : builder).execute();
			const stored = await new ChannelRepository().channelData.findUnique(createChannelID(BigInt(child.id)));
			return stored?.permissionOverwrites.get(everyoneId)?.allow;
		};
		expect(await moveAndRead(true)).toBe(Permissions.SEND_MESSAGES | inThreads);
		expect(await moveAndRead(false)).toBe(Permissions.SEND_MESSAGES);
	});
	test('template imports preserve thread bits and seed everyone permissions', async () => {
		const templated = async (
			token: string,
			everyonePermissions: bigint = Permissions.VIEW_CHANNEL | ThreadPermissionFlags.CREATE_PUBLIC_THREADS,
		) =>
			createBuilder<GuildResponse>(harness, token)
				.post('/guilds')
				.body({
					name: 'Templated',
					template: {
						name: 'Source',
						description: null,
						verification_level: 0,
						default_message_notifications: 0,
						explicit_content_filter: 0,
						system_channel_id: 1,
						afk_timeout: 300,
						system_channel_flags: 0,
						roles: [
							{
								id: 0,
								name: '@everyone',
								permissions: everyonePermissions.toString(),
							},
							{
								id: 2,
								name: 'mods',
								permissions: (Permissions.KICK_MEMBERS | ThreadPermissionFlags.MANAGE_THREADS).toString(),
							},
						],
						channels: [{id: 1, type: ChannelTypes.GUILD_TEXT, name: 'general', position: 0}],
					},
				})
				.execute();
		const owner = await createTestAccount(harness);
		const guild = await templated(owner.token);
		const roles = await listRoles(owner.token, guild.id, true);
		expect(bits(roles.find((role) => role.id === guild.id)?.permissions)).toBe(
			Permissions.VIEW_CHANNEL | ThreadPermissionFlags.CREATE_PUBLIC_THREADS,
		);
		expect(bits(roles.find((role) => role.name === 'mods')?.permissions)).toBe(
			Permissions.KICK_MEMBERS | ThreadPermissionFlags.MANAGE_THREADS,
		);
		const everyoneOf = async (everyonePermissions: bigint) => {
			const created = await templated(owner.token, everyonePermissions);
			const createdRoles = await listRoles(owner.token, created.id, true);
			return bits(createdRoles.find((role) => role.id === created.id)?.permissions);
		};
		expect(await everyoneOf(Permissions.VIEW_CHANNEL | Permissions.SEND_MESSAGES)).toBe(
			Permissions.VIEW_CHANNEL | Permissions.SEND_MESSAGES | DEFAULT_THREAD_PERMISSIONS,
		);
		expect(await everyoneOf(Permissions.VIEW_CHANNEL)).toBe(Permissions.VIEW_CHANNEL);
	});
});