A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// 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}));
}