Skip to content

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

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

import {createGuildID, type GuildID, guildIdToRoleId} from '@app/api/BrandedTypes';
import {mapChannelToResponse} from '@app/api/channel/ChannelMappers';
import type {ThreadRepository} from '@app/api/channel/repositories/ThreadRepository';
import {withThreadParentFieldsMany} from '@app/api/channel/services/thread/ThreadParentSettings';
import {mapGuildRoleToResponse} from '@app/api/guild/GuildModel';
import {Logger} from '@app/api/Logger';
import {createRequestCache} from '@app/api/middleware/RequestCacheMiddleware';
import {getWorkerService} from '@app/api/middleware/ServiceRegistry';
import type {Channel} from '@app/api/models/Channel';
import {getWorkerDependencies} from '@app/api/worker/WorkerContext';
import {Permissions} from '@fluxer/constants/src/ChannelConstants';
import {DEFAULT_THREAD_PERMISSIONS, THREAD_PERMISSIONS} from '@fluxer/constants/src/ThreadPermissionUtils';
import type {WorkerTaskHandler} from '@pkgs/worker/src/contracts/WorkerTask';
import {z} from 'zod';

const PayloadSchema = z.object({
	guildId: z.string(),
});

const SEEDED_GUILD_CACHE_MAX_ENTRIES = 10_000;
const seededGuildIds = new Set<string>();

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

export function seedThreadOverwriteValue(value: bigint): bigint {
	const cleared = seedThreadOverwriteBits(value);
	return (value & Permissions.SEND_MESSAGES) !== 0n ? cleared | DEFAULT_THREAD_PERMISSIONS : cleared;
}

async function enqueueThreadPermissionSeed(guildId: string): Promise<void> {
	await getWorkerService().addJob('seedThreadPermissions', {guildId}, {jobKey: `seed-thread-permissions-${guildId}`});
}

export async function ensureGuildThreadPermissionsSeeded(threads: ThreadRepository, guildId: GuildID): Promise<void> {
	const key = guildId.toString();
	if (seededGuildIds.has(key)) return;
	const marker = await threads.getGuildMarker(guildId);
	if (marker?.perms_seeded_at) {
		if (seededGuildIds.size >= SEEDED_GUILD_CACHE_MAX_ENTRIES) seededGuildIds.clear();
		seededGuildIds.add(key);
		return;
	}
	if (!marker) await threads.ensureGuildMarker(guildId);
	await enqueueThreadPermissionSeed(key);
}

const seedThreadPermissions: WorkerTaskHandler = async (payload) => {
	const validated = PayloadSchema.parse(payload);
	const guildId = createGuildID(BigInt(validated.guildId));
	const {channelRepository, guildRepository, gatewayService, userCacheService} = getWorkerDependencies();

	const marker = await channelRepository.threads.getGuildMarker(guildId);
	if (marker?.perms_seeded_at) return;
	const guild = await guildRepository.findUnique(guildId);
	if (!guild) return;
	await channelRepository.threads.ensureGuildMarker(guildId);
	const channels = await channelRepository.channelData.listGuildChannels(guildId, 'complete');
	const updatedChannels: Array<Channel> = [];
	for (const candidate of channels) {
		if (candidate.permissionOverwrites.size === 0) continue;
		const channel = await channelRepository.channelData.findUnique(candidate.id);
		if (!channel || channel.permissionOverwrites.size === 0) continue;
		let changed = false;
		const overwrites = new Map(
			Array.from(channel.permissionOverwrites.entries()).map(([targetId, overwrite]) => {
				const allow = seedThreadOverwriteValue(overwrite.allow);
				const deny = seedThreadOverwriteValue(overwrite.deny);
				if (allow !== overwrite.allow || deny !== overwrite.deny) changed = true;
				return [targetId, {type: overwrite.type, allow_: allow, deny_: deny}];
			}),
		);
		if (!changed) continue;
		updatedChannels.push(
			await channelRepository.channelData.upsert(
				{...channel.toRow(), permission_overwrites: overwrites},
				channel.toRow(),
			),
		);
	}
	const everyone = await guildRepository.getRole(guildIdToRoleId(guildId), guildId);
	const everyoneSeeded =
		everyone && (everyone.permissions & Permissions.SEND_MESSAGES) !== 0n
			? everyone.permissions | DEFAULT_THREAD_PERMISSIONS
			: null;
	const updatedRole =
		everyone && everyoneSeeded !== null && everyoneSeeded !== everyone.permissions
			? await guildRepository.upsertRole({...everyone.toRow(), permissions: everyoneSeeded})
			: null;
	if (updatedRole) {
		await gatewayService.dispatchGuild({
			guildId,
			event: 'GUILD_ROLE_UPDATE_BULK',
			data: {roles: [mapGuildRoleToResponse(updatedRole)]},
		});
	}
	if (updatedChannels.length > 0) {
		const requestCache = createRequestCache();
		const channelResponses = await Promise.all(
			updatedChannels.map((channel) =>
				mapChannelToResponse({channel, currentUserId: null, userCacheService, requestCache}),
			),
		);
		await gatewayService.dispatchGuild({
			guildId,
			event: 'CHANNEL_UPDATE_BULK',
			data: {
				channels: await withThreadParentFieldsMany(
					channelRepository.threads,
					guildId,
					updatedChannels,
					channelResponses,
				),
			},
		});
	}
	await channelRepository.threads.markGuildPermsSeeded(guildId, new Date());
	Logger.info(
		{guildId: guildId.toString(), channels: updatedChannels.length, everyoneUpdated: updatedRole !== null},
		'Seeded thread permissions',
	);
};

export default seedThreadPermissions;