Skip to content

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

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

import {readFileSync} from 'node:fs';
import {fileURLToPath} from 'node:url';
import {
	type ChannelID,
	channelIdToMessageId,
	createChannelID,
	createGuildID,
	createMessageID,
	createUserID,
	type GuildID,
} from '@app/api/BrandedTypes';
import {ChannelRepository} from '@app/api/channel/ChannelRepository';
import {type CreateThreadParams, ThreadRepository} from '@app/api/channel/repositories/ThreadRepository';
import {
	type CassandraQueryExecutorForTesting,
	deleteOneOrMany,
	executeConditional,
	fetchMany,
	fetchOne,
	setCassandraQueryExecutorForTesting,
	upsertOne,
} from '@app/api/database/CassandraQueryExecution';
import type {CassandraParams, KvQueryMeta, PreparedQuery} from '@app/api/database/CassandraTypes';
import type {ChannelRow} from '@app/api/database/types/ChannelTypes';
import {clearChannelThreadsTaintCacheForTesting} from '@app/api/experiment/ChannelThreadsGate';
import {
	ActiveThreadsByGuild,
	ArchivedThreadsByParent,
	Channels,
	ChannelsByGuild,
	ForumPinnedThread,
	GuildThreadState,
	Messages,
	ThreadMembers,
	ThreadMembersByUser,
	ThreadOnlyChannelsByGuild,
	ThreadParentConfig,
	ThreadState,
	ThreadStats,
	ThreadsByParent,
} from '@app/api/Tables';
import {InMemoryCassandraQueryExecutor} from '@app/api/test/InMemoryCassandraQueryExecutor';
import {ChannelTypes} from '@fluxer/constants/src/ChannelConstants';
import {ChannelFlags, MAX_THREAD_MEMBERS} from '@fluxer/constants/src/ThreadConstants';
import {MaxThreadMembersError} from '@fluxer/errors/src/domains/channel/MaxThreadMembersError';
import {ThreadAlreadyCreatedForMessageError} from '@fluxer/errors/src/domains/channel/ThreadAlreadyCreatedForMessageError';
import {createSnowflakeFromTimestamp} from '@fluxer/snowflake/src/Snowflake';
import {afterEach, beforeEach, describe, expect, it} from 'vitest';

const GUILD_ID = createGuildID(1_900_000_000_000_000_000n);
const PARENT_ID = createChannelID(1_900_000_000_000_000_100n);
const FORUM_ID = createChannelID(1_900_000_000_000_000_200n);
const OWNER_ID = createUserID(1_900_000_000_000_001_000n);

class RecordingExecutor implements CassandraQueryExecutorForTesting {
	readonly statements: Array<string> = [];

	constructor(private readonly inner: CassandraQueryExecutorForTesting) {}

	async executeQuery<T = Record<string, unknown>, P extends CassandraParams = CassandraParams>(
		query: PreparedQuery<P>,
	): Promise<Array<T>> {
		const meta = query.kvMeta;
		this.record(meta, meta?.conditions || meta?.ifNotExists || meta?.batchEntries ? 'cas' : undefined);
		return this.inner.executeQuery<T, P>(query);
	}

	async executeBatch(
		queries: Array<{query: string; params: object; meta?: KvQueryMeta}>,
		atomic?: boolean,
	): Promise<void> {
		for (const entry of queries) this.record(entry.meta);
		await this.inner.executeBatch(queries, atomic);
	}

	count(statement: string): number {
		return this.statements.filter((entry) => entry === statement).length;
	}

	private record(meta: KvQueryMeta | undefined, prefix?: string): void {
		if (!meta) return;
		this.statements.push(`${prefix ?? meta.action}:${meta.table.name}`);
	}
}

function channelRow(channelId: ChannelID, type: number, overrides: Partial<ChannelRow> = {}): ChannelRow {
	return {
		channel_id: channelId,
		guild_id: GUILD_ID,
		type,
		name: `channel-${channelId}`,
		topic: null,
		icon_hash: null,
		url: null,
		parent_id: null,
		position: 0,
		owner_id: null,
		recipient_ids: null,
		nsfw: false,
		content_warning_level: null,
		content_warning_text: null,
		rate_limit_per_user: 0,
		bitrate: null,
		user_limit: null,
		voice_connection_limit: null,
		rtc_region: null,
		rtc_p2p: null,
		last_message_id: null,
		last_pin_timestamp: null,
		permission_overwrites: null,
		nicks: null,
		soft_deleted: false,
		indexed_at: null,
		version: 1,
		...overrides,
	};
}

let lastId = 0n;
function freshThreadId(offsetMs = 0): ChannelID {
	const base = createSnowflakeFromTimestamp(Date.now() + offsetMs);
	if (offsetMs !== 0) return createChannelID(base);
	lastId = base > lastId ? base : lastId + 1n;
	return createChannelID(lastId);
}

function createParams(threadId: ChannelID, overrides: Partial<CreateThreadParams> = {}): CreateThreadParams {
	const type = overrides.channel?.type ?? ChannelTypes.PUBLIC_THREAD;
	return {
		channel: channelRow(threadId, type, {parent_id: PARENT_ID, owner_id: OWNER_ID, indexed_at: new Date()}),
		parentType: ChannelTypes.GUILD_TEXT,
		autoArchiveDuration: 4320,
		invitable: null,
		flags: 0,
		appliedTags: [],
		hasStarter: false,
		createdAt: new Date(),
		members: [{userId: OWNER_ID, flags: 1}],
		...overrides,
	};
}

function describeThreadRepository(backend: string, makeExecutor: () => Promise<CassandraQueryExecutorForTesting>) {
	describe(`ThreadRepository (${backend})`, () => {
		let executor: RecordingExecutor;
		let repositories: ChannelRepository;

		beforeEach(async () => {
			executor = new RecordingExecutor(await makeExecutor());
			setCassandraQueryExecutorForTesting(executor);
			clearChannelThreadsTaintCacheForTesting();
			repositories = new ChannelRepository();
			await upsertOne(Channels.upsertAll(channelRow(PARENT_ID, ChannelTypes.GUILD_TEXT)));
			await upsertOne(ChannelsByGuild.upsertAll({guild_id: GUILD_ID, channel_id: PARENT_ID}));
			executor.statements.length = 0;
		});

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

		async function taint(guildId: GuildID = GUILD_ID): Promise<void> {
			clearChannelThreadsTaintCacheForTesting();
			await upsertOne(
				GuildThreadState.upsertAll({
					guild_id: guildId,
					first_active_at: new Date(),
					perms_seeded_at: null,
					search_backfilled_at: null,
				}),
			);
		}

		it('writes a thread into its side tables and never into the guild channel index', async () => {
			const threadId = freshThreadId();
			const state = await repositories.threads.create(createParams(threadId));
			expect(state.stateVersion).toBe(1);
			expect(state.memberCount).toBe(1);
			expect(state.memberIdsPreview).toEqual([OWNER_ID]);
			const channel = await repositories.channelData.findUnique(threadId);
			expect(channel?.isThread()).toBe(true);
			expect(await repositories.channelData.listGuildChannels(GUILD_ID, 'enrolled')).toHaveLength(1);
			expect(
				await fetchOne(
					ChannelsByGuild.selectCql({
						where: [ChannelsByGuild.where.eq('guild_id'), ChannelsByGuild.where.eq('channel_id')],
					}),
					{guild_id: GUILD_ID, channel_id: threadId},
				),
			).toBeNull();
			expect((await repositories.threads.listActiveThreads(GUILD_ID)).map((t) => t.threadId)).toEqual([threadId]);
			expect(await repositories.threads.listThreadIdsByParent(PARENT_ID, {limit: 10})).toEqual([threadId]);
			expect((await repositories.threads.getParentConfig(GUILD_ID, PARENT_ID))?.hasThreads).toBe(true);
			expect((await repositories.threads.getMember(threadId, OWNER_ID))?.flags).toBe(1);
		});

		it('lets exactly one of two concurrent creates win', async () => {
			const threadId = freshThreadId();
			const results = await Promise.allSettled([
				repositories.threads.create(createParams(threadId)),
				repositories.threads.create(createParams(threadId)),
			]);
			expect(results.filter((result) => result.status === 'fulfilled')).toHaveLength(1);
			const rejected = results.find((result) => result.status === 'rejected') as PromiseRejectedResult;
			expect(rejected.reason).toBeInstanceOf(ThreadAlreadyCreatedForMessageError);
		});

		it('refuses a create over a fresh dangling state and repairs one older than 30 seconds', async () => {
			const threadId = freshThreadId();
			const dangling = {
				thread_id: threadId,
				guild_id: GUILD_ID,
				parent_id: PARENT_ID,
				type: ChannelTypes.PUBLIC_THREAD,
				archived: false,
				locked: false,
				invitable: null,
				auto_archive_duration: 4320,
				archive_timestamp: new Date(),
				created_at: new Date(),
				flags: 0,
				applied_tags: null,
				member_count: 0,
				member_ids_preview: null,
				has_starter: false,
				state_version: 1,
			};
			expect(await executeConditional(ThreadState.insertIfNotExists(dangling))).toBe(true);
			await expect(repositories.threads.create(createParams(threadId))).rejects.toBeInstanceOf(
				ThreadAlreadyCreatedForMessageError,
			);
			const staleId = freshThreadId();
			expect(
				await executeConditional(
					ThreadState.insertIfNotExists({...dangling, thread_id: staleId, created_at: new Date(Date.now() - 31_000)}),
				),
			).toBe(true);
			const repaired = await repositories.threads.create(createParams(staleId));
			expect(repaired.memberCount).toBe(1);
			expect(await repositories.channelData.findUnique(staleId)).not.toBeNull();
		});

		it('clears the crashed creator memberships when repairing a dangling create', async () => {
			const threadId = freshThreadId();
			const crashed = createUserID(1_900_000_000_000_003_000n);
			const createdAt = new Date(Date.now() - 31_000);
			expect(
				await executeConditional(
					ThreadState.insertIfNotExists({
						thread_id: threadId,
						guild_id: GUILD_ID,
						parent_id: PARENT_ID,
						type: ChannelTypes.PRIVATE_THREAD,
						archived: false,
						locked: false,
						invitable: true,
						auto_archive_duration: 4320,
						archive_timestamp: createdAt,
						created_at: createdAt,
						flags: 0,
						applied_tags: null,
						member_count: 1,
						member_ids_preview: [crashed],
						has_starter: false,
						state_version: 1,
					}),
				),
			).toBe(true);
			const memberRow = {
				thread_id: threadId,
				guild_id: GUILD_ID,
				parent_id: PARENT_ID,
				join_timestamp: createdAt,
				flags: 1,
				muted: false,
				mute_config: null,
			};
			await upsertOne(ThreadMembers.upsertAll({...memberRow, user_id: crashed}));
			await upsertOne(ThreadMembers.upsertAll({...memberRow, user_id: OWNER_ID}));
			await upsertOne(
				ThreadMembersByUser.upsertAll({
					user_id: crashed,
					guild_id: GUILD_ID,
					parent_id: PARENT_ID,
					is_private: true,
					thread_id: threadId,
				}),
			);
			const repaired = await repositories.threads.create(createParams(threadId));
			expect(repaired.memberCount).toBe(1);
			const members = await repositories.threads.listMembers(threadId, {limit: 10});
			expect(members.map((member) => member.userId)).toEqual([OWNER_ID]);
			expect(members[0]!.joinTimestamp.getTime()).not.toBe(createdAt.getTime());
			expect(await repositories.threads.listJoinedThreadIds(crashed, GUILD_ID)).toEqual([]);
		});

		it('removes a private membership index row when the thread state is gone', async () => {
			const threadId = freshThreadId();
			const params = createParams(threadId);
			params.channel.type = ChannelTypes.PRIVATE_THREAD;
			await repositories.threads.create(params);
			await deleteOneOrMany(ThreadState.deleteByPk({thread_id: threadId}));
			const result = await repositories.threads.removeMembers(threadId, [OWNER_ID]);
			expect(result.removed.map((member) => member.userId)).toEqual([OWNER_ID]);
			expect(await repositories.threads.listJoinedThreadIds(OWNER_ID, GUILD_ID)).toEqual([]);
		});

		it('ignores a dangling threads_by_parent row in lists but enumerates it for maintenance', async () => {
			await taint();
			const threadId = freshThreadId();
			await upsertOne(
				ThreadsByParent.upsertAll({
					parent_id: PARENT_ID,
					thread_id: threadId,
					guild_id: GUILD_ID,
					type: ChannelTypes.PUBLIC_THREAD,
				}),
			);
			expect(await repositories.threads.listActiveThreads(GUILD_ID)).toEqual([]);
			expect(await repositories.threads.listGuildThreadIds(GUILD_ID)).toEqual([threadId]);
		});

		it('moves index rows on archive and unarchive and clears the pin', async () => {
			const threadId = freshThreadId();
			await repositories.threads.create(createParams(threadId, {flags: ChannelFlags.PINNED}));
			expect(await repositories.threads.claimForumPin(FORUM_ID, threadId)).toBe(true);
			await upsertOne(ThreadState.patchByPk({thread_id: threadId}, {parent_id: {kind: 'set', value: FORUM_ID}}));
			const archived = await repositories.threads.updateState(threadId, () => ({archived: true}));
			expect(archived?.state.archived).toBe(true);
			expect(archived?.state.isPinned).toBe(false);
			expect(archived?.state.stateVersion).toBe(2);
			expect(await repositories.threads.getForumPin(FORUM_ID)).toBeNull();
			expect(await repositories.threads.listActiveThreads(GUILD_ID)).toEqual([]);
			const page = await repositories.threads.listArchivedThreads(FORUM_ID, false, {limit: 10});
			expect(page.threads.map((t) => t.threadId)).toEqual([threadId]);
			const unarchived = await repositories.threads.updateState(threadId, () => ({archived: false}));
			expect(unarchived?.state.archived).toBe(false);
			expect((await repositories.threads.listActiveThreads(GUILD_ID)).map((t) => t.threadId)).toEqual([threadId]);
			expect((await repositories.threads.listArchivedThreads(FORUM_ID, false, {limit: 10})).threads).toEqual([]);
		});

		it('serialises racing transitions through the state version', async () => {
			const threadId = freshThreadId();
			await repositories.threads.create(createParams(threadId));
			const [archive, lock] = await Promise.all([
				repositories.threads.updateState(threadId, () => ({archived: true})),
				repositories.threads.updateState(threadId, () => ({locked: true})),
			]);
			expect(archive).not.toBeNull();
			expect(lock).not.toBeNull();
			const state = await repositories.threads.getState(threadId);
			expect(state?.archived).toBe(true);
			expect(state?.locked).toBe(true);
			expect(state?.stateVersion).toBe(3);
			expect(await repositories.threads.listActiveThreads(GUILD_ID)).toEqual([]);
			expect((await repositories.threads.listArchivedThreads(PARENT_ID, false, {limit: 10})).threads).toHaveLength(1);
		});

		it('drops and reports stale index rows, and repairs missing ones', async () => {
			const drifted: Array<Array<ChannelID>> = [];
			const threads = new ThreadRepository(repositories.channelData, repositories.messages, (threadIds) => {
				drifted.push(threadIds);
			});
			const threadId = freshThreadId();
			await threads.create(createParams(threadId));
			await threads.updateState(threadId, () => ({archived: true}));
			await upsertOne(
				ActiveThreadsByGuild.upsertAll({
					guild_id: GUILD_ID,
					thread_id: threadId,
					parent_id: PARENT_ID,
					type: ChannelTypes.PUBLIC_THREAD,
				}),
			);
			expect(await threads.listActiveThreads(GUILD_ID)).toEqual([]);
			expect(drifted).toContainEqual([threadId]);
			expect(
				await fetchMany(ActiveThreadsByGuild.selectCql({where: ActiveThreadsByGuild.where.eq('guild_id')}), {
					guild_id: GUILD_ID,
				}),
			).toEqual([]);
			const state = await threads.getState(threadId);
			await executeConditional(
				ArchivedThreadsByParent.conditionalDeleteByPk(
					{parent_id: PARENT_ID, is_private: false, archive_timestamp: state!.archiveTimestamp!, thread_id: threadId},
					{guild_id: GUILD_ID},
				),
			);
			expect((await threads.listArchivedThreads(PARENT_ID, false, {limit: 10})).threads).toEqual([]);
			await threads.repairThreadIndexes([threadId]);
			expect((await threads.listArchivedThreads(PARENT_ID, false, {limit: 10})).threads).toHaveLength(1);
		});

		it('claims one pinned post per forum and recovers a stale claim', async () => {
			const first = freshThreadId();
			const second = freshThreadId();
			await repositories.threads.create(createParams(first, {flags: ChannelFlags.PINNED}));
			await repositories.threads.create(createParams(second));
			expect(await repositories.threads.claimForumPin(FORUM_ID, first)).toBe(true);
			expect(await repositories.threads.claimForumPin(FORUM_ID, first)).toBe(true);
			expect(await repositories.threads.claimForumPin(FORUM_ID, second)).toBe(false);
			await upsertOne(ThreadState.patchByPk({thread_id: first}, {flags: {kind: 'set', value: 0}}));
			expect(await repositories.threads.claimForumPin(FORUM_ID, second)).toBe(true);
			expect(await repositories.threads.getForumPin(FORUM_ID)).toBe(second);
		});

		it('pages archived threads newest first with before cursors and limits 2 and 100', async () => {
			const ids: Array<ChannelID> = [];
			for (let i = 0; i < 5; i++) {
				const threadId = freshThreadId();
				ids.push(threadId);
				await repositories.threads.create(createParams(threadId));
				await repositories.threads.updateState(threadId, () => ({
					archived: true,
					archive_timestamp: new Date(1_700_000_000_000 + i * 1000),
				}));
			}
			const newestFirst = [...ids].reverse();
			const first = await repositories.threads.listArchivedThreads(PARENT_ID, false, {limit: 2});
			expect(first.threads.map((t) => t.threadId)).toEqual(newestFirst.slice(0, 2));
			expect(first.hasMore).toBe(true);
			const second = await repositories.threads.listArchivedThreads(PARENT_ID, false, {
				limit: 2,
				before: first.threads[1]!.archiveTimestamp!,
			});
			expect(second.threads.map((t) => t.threadId)).toEqual(newestFirst.slice(2, 4));
			expect(second.hasMore).toBe(true);
			const all = await repositories.threads.listArchivedThreads(PARENT_ID, false, {limit: 100});
			expect(all.threads.map((t) => t.threadId)).toEqual(newestFirst);
			expect(all.hasMore).toBe(false);
			expect((await repositories.threads.listArchivedThreads(PARENT_ID, true, {limit: 100})).threads).toEqual([]);
		});

		it('pages past stale rows when several archived threads share one timestamp', async () => {
			const tied = new Date(1_700_000_000_000);
			const ids: Array<ChannelID> = [];
			for (let i = 0; i < 4; i++) {
				const threadId = freshThreadId();
				ids.push(threadId);
				await repositories.threads.create(createParams(threadId));
				await repositories.threads.updateState(threadId, () => ({archived: true, archive_timestamp: tied}));
			}
			const older = freshThreadId();
			await repositories.threads.create(createParams(older));
			await repositories.threads.updateState(older, () => ({
				archived: true,
				archive_timestamp: new Date(tied.getTime() - 1000),
			}));
			for (const offset of [1n, 2n]) {
				await upsertOne(
					ArchivedThreadsByParent.upsertAll({
						parent_id: PARENT_ID,
						is_private: false,
						archive_timestamp: tied,
						thread_id: createChannelID(ids[3]! + 1000n * offset),
						guild_id: GUILD_ID,
					}),
				);
			}
			const newestFirst = [...ids].reverse();
			const first = await repositories.threads.listArchivedThreads(PARENT_ID, false, {limit: 2});
			expect(first.threads.map((t) => t.threadId)).toEqual(newestFirst.slice(0, 2));
			expect(first.hasMore).toBe(true);
			const all = await repositories.threads.listArchivedThreads(PARENT_ID, false, {limit: 4});
			expect(all.threads.map((t) => t.threadId)).toEqual(newestFirst);
			expect(all.hasMore).toBe(true);
		});

		it('lists only joined private archived threads, newest id first', async () => {
			const member = createUserID(1_900_000_000_000_002_000n);
			const privateIds: Array<ChannelID> = [];
			for (let i = 0; i < 3; i++) {
				const threadId = freshThreadId();
				privateIds.push(threadId);
				const params = createParams(threadId, {members: [{userId: member, flags: 1}]});
				params.channel.type = ChannelTypes.PRIVATE_THREAD;
				await repositories.threads.create(params);
				await repositories.threads.updateState(threadId, () => ({archived: true}));
			}
			const publicId = freshThreadId();
			await repositories.threads.create(createParams(publicId, {members: [{userId: member, flags: 1}]}));
			await repositories.threads.updateState(publicId, () => ({archived: true}));
			executor.statements.length = 0;
			const page = await repositories.threads.listJoinedPrivateArchivedThreads(member, GUILD_ID, PARENT_ID, {limit: 2});
			expect(page.threads.map((t) => t.threadId)).toEqual([privateIds[2], privateIds[1]]);
			expect(page.hasMore).toBe(true);
			const next = await repositories.threads.listJoinedPrivateArchivedThreads(member, GUILD_ID, PARENT_ID, {
				limit: 2,
				before: privateIds[1],
			});
			expect(next.threads.map((t) => t.threadId)).toEqual([privateIds[0]]);
			expect(next.hasMore).toBe(false);
			expect(page.threads.every((t) => t.isPrivate)).toBe(true);
		});

		it('adds a 250 member batch with one state compare-and-set', async () => {
			const threadId = freshThreadId();
			await repositories.threads.create(createParams(threadId));
			executor.statements.length = 0;
			const members = Array.from({length: 250}, (_, index) => ({
				userId: createUserID(1_900_000_000_010_000_000n + BigInt(index)),
				flags: 0,
			}));
			const result = await repositories.threads.addMembers(threadId, members);
			expect(result?.added).toHaveLength(250);
			expect(result?.state.memberCount).toBe(251);
			expect(result?.state.memberIdsPreview).toHaveLength(8);
			expect(result?.state.memberIdsPreview[0]).toBe(members[249]!.userId);
			expect(executor.count('cas:thread_state')).toBe(1);
			expect(executor.count('cas:thread_members')).toBe(1);
			const again = await repositories.threads.addMembers(threadId, members.slice(0, 3));
			expect(again?.added).toEqual([]);
			expect((await repositories.threads.listMembers(threadId, {limit: 1000})).length).toBe(251);
		});

		it('writes creator memberships and the seeded stamp only under compare-and-set', async () => {
			const threadId = freshThreadId();
			await repositories.threads.create(
				createParams(threadId, {
					members: [
						{userId: OWNER_ID, flags: 1},
						{userId: OWNER_ID, flags: 1},
					],
				}),
			);
			expect(executor.count('cas:thread_members')).toBe(1);
			expect(executor.statements.some((entry) => entry.endsWith(':thread_members') && !entry.startsWith('cas:'))).toBe(
				false,
			);
			expect((await repositories.threads.listMembers(threadId, {limit: 10})).map((m) => m.userId)).toEqual([OWNER_ID]);
			const guildId = createGuildID(1_900_000_000_000_000_777n);
			await repositories.threads.ensureGuildMarker(guildId);
			expect((await repositories.threads.getGuildMarker(guildId))?.perms_seeded_at ?? null).toBeNull();
			executor.statements.length = 0;
			const seededAt = new Date(1_800_000_000_000);
			await repositories.threads.markGuildPermsSeeded(guildId, seededAt);
			await repositories.threads.markGuildPermsSeeded(guildId, new Date());
			expect((await repositories.threads.getGuildMarker(guildId))?.perms_seeded_at).toEqual(seededAt);
			expect(
				executor.statements.filter((entry) => entry.endsWith(':guild_thread_state') && !entry.startsWith('select:')),
			).toEqual(['cas:guild_thread_state']);
			const fresh = createGuildID(1_900_000_000_000_000_778n);
			await repositories.threads.markGuildPermsSeeded(fresh, seededAt);
			expect((await repositories.threads.getGuildMarker(fresh))?.perms_seeded_at).toEqual(seededAt);
		});

		it('marks search backfill on a full marker row and clears it for a reindex', async () => {
			const guildId = createGuildID(1_900_000_000_000_000_779n);
			const at = new Date(1_800_000_000_000);
			await repositories.threads.markGuildSearchBackfilled(guildId, at);
			const marker = await repositories.threads.getGuildMarker(guildId);
			expect(marker?.first_active_at).toBeInstanceOf(Date);
			expect(marker?.search_backfilled_at).toEqual(at);
			await repositories.threads.clearGuildSearchBackfilled(guildId);
			const cleared = await repositories.threads.getGuildMarker(guildId);
			expect(cleared?.search_backfilled_at ?? null).toBeNull();
			expect(cleared?.first_active_at).toEqual(marker?.first_active_at);
		});

		it('refuses joins past the member cap', async () => {
			const threadId = freshThreadId();
			await repositories.threads.create(createParams(threadId));
			await upsertOne(
				ThreadState.patchByPk({thread_id: threadId}, {member_count: {kind: 'set', value: MAX_THREAD_MEMBERS - 1}}),
			);
			await expect(
				repositories.threads.addMembers(threadId, [
					{userId: createUserID(1_900_000_000_020_000_001n), flags: 0},
					{userId: createUserID(1_900_000_000_020_000_002n), flags: 0},
				]),
			).rejects.toBeInstanceOf(MaxThreadMembersError);
			const single = await repositories.threads.addMembers(threadId, [
				{userId: createUserID(1_900_000_000_020_000_003n), flags: 0},
			]);
			expect(single?.state.memberCount).toBe(MAX_THREAD_MEMBERS);
		});

		it('lets only one of two concurrent joins take the last member slot', async () => {
			const threadId = freshThreadId();
			await repositories.threads.create(createParams(threadId));
			await upsertOne(
				ThreadState.patchByPk({thread_id: threadId}, {member_count: {kind: 'set', value: MAX_THREAD_MEMBERS - 1}}),
			);
			const joiners = [createUserID(1_900_000_000_025_000_001n), createUserID(1_900_000_000_025_000_002n)];
			const results = await Promise.allSettled(
				joiners.map((userId) => repositories.threads.addMembers(threadId, [{userId, flags: 0}])),
			);
			expect(results.filter((result) => result.status === 'fulfilled')).toHaveLength(1);
			const rejected = results.find((result) => result.status === 'rejected') as PromiseRejectedResult;
			expect(rejected.reason).toBeInstanceOf(MaxThreadMembersError);
			expect((await repositories.threads.getState(threadId))?.memberCount).toBe(MAX_THREAD_MEMBERS);
			expect(await repositories.threads.listMembers(threadId, {limit: 100})).toHaveLength(2);
		});

		it('keeps the member count consistent under concurrent adds and removes', async () => {
			const threadId = freshThreadId();
			const leaving = createUserID(1_900_000_000_030_000_001n);
			await repositories.threads.create(
				createParams(threadId, {
					members: [
						{userId: OWNER_ID, flags: 1},
						{userId: leaving, flags: 0},
					],
				}),
			);
			const joiners = [createUserID(1_900_000_000_030_000_002n), createUserID(1_900_000_000_030_000_003n)];
			await Promise.all([
				repositories.threads.addMembers(
					threadId,
					joiners.map((userId) => ({userId, flags: 0})),
				),
				repositories.threads.removeMembers(threadId, [leaving]),
				repositories.threads.removeMembers(threadId, [leaving]),
			]);
			const state = await repositories.threads.getState(threadId);
			const rows = await repositories.threads.listMembers(threadId, {limit: 100});
			expect(rows.map((row) => row.userId).sort()).toEqual([OWNER_ID, ...joiners].sort());
			expect(state?.memberCount).toBe(3);
			expect(state?.memberIdsPreview).not.toContain(leaving);
			expect(await repositories.threads.listJoinedThreadIds(leaving, GUILD_ID)).toEqual([]);
		});

		it('counts inserted thread messages only, excludes the starter id and floors at zero', async () => {
			const threadId = freshThreadId();
			await repositories.threads.create(createParams(threadId));
			await repositories.channelData.updateLastMessageId(threadId, channelIdToMessageId(threadId), {isInsert: true});
			expect((await repositories.threads.getStats(threadId)).messageCount).toBe(0);
			await repositories.channelData.updateLastMessageId(threadId, createMessageID(threadId + 10n));
			expect((await repositories.threads.getStats(threadId)).messageCount).toBe(0);
			await repositories.channelData.updateLastMessageId(threadId, createMessageID(threadId + 20n), {isInsert: true});
			await repositories.channelData.updateLastMessageId(threadId, createMessageID(threadId + 30n), {isInsert: true});
			const stats = await repositories.threads.getStats(threadId);
			expect(stats.messageCount).toBe(2);
			expect(stats.totalMessageSent).toBe(2);
			await repositories.threads.adjustMessageCount(threadId, -5);
			const floored = await repositories.threads.getStats(threadId);
			expect(floored.messageCount).toBe(0);
			expect(floored.totalMessageSent).toBe(2);
			executor.statements.length = 0;
			await repositories.channelData.updateLastMessageId(PARENT_ID, createMessageID(threadId + 40n), {isInsert: true});
			expect(executor.count('select:thread_stats')).toBe(0);
		});

		it('keeps thread message counters exact under concurrent sends and deletes', async () => {
			const threadId = freshThreadId();
			await repositories.threads.create(createParams(threadId));
			await Promise.all(
				Array.from({length: 8}, (_, index) =>
					repositories.channelData.updateLastMessageId(threadId, createMessageID(threadId + BigInt(index + 1)), {
						isInsert: true,
					}),
				),
			);
			const sent = await repositories.threads.getStats(threadId);
			expect(sent.messageCount).toBe(8);
			expect(sent.totalMessageSent).toBe(8);
			await Promise.all([
				repositories.threads.adjustMessageCount(threadId, -1),
				repositories.threads.adjustMessageCount(threadId, -1),
				repositories.channelData.updateLastMessageId(threadId, createMessageID(threadId + 100n), {isInsert: true}),
			]);
			const mixed = await repositories.threads.getStats(threadId);
			expect(mixed.messageCount).toBe(7);
			expect(mixed.totalMessageSent).toBe(9);
		});

		it('enumerates guild threads with and without an activity cutoff', async () => {
			await taint();
			const oldThread = freshThreadId(-86_400_000);
			const newThread = freshThreadId();
			await repositories.threads.create(createParams(oldThread));
			await repositories.threads.create(createParams(newThread));
			await repositories.channelData.updateLastMessageId(
				newThread,
				createMessageID(createSnowflakeFromTimestamp(Date.now())),
			);
			expect((await repositories.threads.listGuildThreadIds(GUILD_ID)).sort()).toEqual([oldThread, newThread].sort());
			expect(
				await repositories.threads.listGuildThreadIds(GUILD_ID, {activeSince: new Date(Date.now() - 3_600_000)}),
			).toEqual([newThread]);
		});

		it('indexes forums separately, merges them into guild collections, and removes their side index on deletion', async () => {
			await repositories.channelData.upsert(channelRow(FORUM_ID, ChannelTypes.GUILD_FORUM));
			expect(
				await fetchMany(ThreadOnlyChannelsByGuild.selectCql({where: ThreadOnlyChannelsByGuild.where.eq('guild_id')}), {
					guild_id: GUILD_ID,
				}),
			).toHaveLength(1);

			expect(
				new Set((await repositories.channelData.listGuildChannels(GUILD_ID, 'enrolled')).map((c) => c.id)),
			).toEqual(new Set([PARENT_ID, FORUM_ID]));
			await taint();
			expect(
				new Set((await repositories.channelData.listGuildChannels(GUILD_ID, 'maintenance')).map((c) => c.id)),
			).toEqual(new Set([PARENT_ID, FORUM_ID]));
			await repositories.channelData.delete(FORUM_ID, GUILD_ID, ChannelTypes.GUILD_FORUM);
			expect(
				await fetchMany(ThreadOnlyChannelsByGuild.selectCql({where: ThreadOnlyChannelsByGuild.where.eq('guild_id')}), {
					guild_id: GUILD_ID,
				}),
			).toEqual([]);
		});

		it('purges every thread row with threads_by_parent last', async () => {
			const threadId = freshThreadId();
			await repositories.threads.create(createParams(threadId, {members: [{userId: OWNER_ID, flags: 1}]}));
			await repositories.threads.updateState(threadId, () => ({archived: true}));
			executor.statements.length = 0;
			await repositories.threads.purgeThread(threadId);
			expect(executor.statements.at(-1)).toBe('delete:threads_by_parent');
			expect(await repositories.threads.getState(threadId)).toBeNull();
			expect(await repositories.channelData.findUnique(threadId)).toBeNull();
			expect(await repositories.threads.listMembers(threadId, {limit: 10})).toEqual([]);
			expect(await repositories.threads.listJoinedThreadIds(OWNER_ID, GUILD_ID)).toEqual([]);
			expect((await repositories.threads.listArchivedThreads(PARENT_ID, false, {limit: 10})).threads).toEqual([]);
			expect(await repositories.threads.listThreadIdsByParent(PARENT_ID, {limit: 10})).toEqual([]);
		});

		it('stores parent config through plain patches', async () => {
			await repositories.threads.patchParentConfig(GUILD_ID, FORUM_ID, {
				flags: ChannelFlags.REQUIRE_TAG,
				available_tags: [{id: 5n, name: 'bug', moderated: false, emoji_id: null, emoji_name: '🐛'}],
				default_sort_order: 1,
			});
			const config = await repositories.threads.getParentConfig(GUILD_ID, FORUM_ID);
			expect(config?.flags).toBe(ChannelFlags.REQUIRE_TAG);
			expect(config?.availableTags.map((tag) => tag.toUdt())).toEqual([
				{id: 5n, name: 'bug', moderated: false, emoji_id: null, emoji_name: '🐛'},
			]);
			await repositories.threads.patchParentConfig(GUILD_ID, FORUM_ID, {available_tags: []});
			expect((await repositories.threads.getParentConfig(GUILD_ID, FORUM_ID))?.availableTags).toEqual([]);
			expect(await repositories.threads.listParentConfigs(GUILD_ID)).toHaveLength(1);
			await repositories.threads.deleteParentConfig(GUILD_ID, FORUM_ID);
			expect(
				await fetchOne(
					ThreadParentConfig.selectCql({
						where: [ThreadParentConfig.where.eq('guild_id'), ThreadParentConfig.where.eq('channel_id')],
					}),
					{guild_id: GUILD_ID, channel_id: FORUM_ID},
				),
			).toBeNull();
		});
	});
}

const THREAD_TABLES = [
	ThreadState,
	ThreadStats,
	ThreadsByParent,
	ActiveThreadsByGuild,
	ArchivedThreadsByParent,
	ThreadMembers,
	ThreadMembersByUser,
	ThreadParentConfig,
	ForumPinnedThread,
	ThreadOnlyChannelsByGuild,
	GuildThreadState,
	Channels,
	Messages,
];

describe('thread storage leaves control storage untouched', () => {
	it('declares every thread table in the target schema with the same columns and no TTL', () => {
		const schema = JSON.parse(
			readFileSync(
				fileURLToPath(new URL('../../../../../tools/dev/cassandra_target_schema.json', import.meta.url)),
				'utf8',
			),
		) as {tables: Array<{name: string; columns: Array<{name: string}>; options: string}>};
		for (const table of THREAD_TABLES) {
			const declared = schema.tables.find((entry) => entry.name === table.name);
			expect(declared, table.name).toBeDefined();
			expect(new Set(declared!.columns.map((column) => column.name))).toEqual(new Set(table.columns));
			expect(declared!.options).not.toContain('default_time_to_live');
			expect(table.defaultTtlSeconds).toBeUndefined();
		}
	});
});

describeThreadRepository('in-memory cassandra', async () => new InMemoryCassandraQueryExecutor());