Skip to content

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

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

import {createInviteCode, type GuildID, type UserID, vanityCodeToInviteCode} from '@app/api/BrandedTypes';
import {Config} from '@app/api/Config';
import {mapChannelToResponse} from '@app/api/channel/ChannelMappers';
import {withThreadParentFieldsMany} from '@app/api/channel/services/thread/ThreadParentSettings';
import type {GuildVisitRow} from '@app/api/database/types/GuildVisitTypes';
import {type ThreadViewer, viewerActive} from '@app/api/experiment/ChannelThreadsGate';
import {userGuildVisitsActive} from '@app/api/experiment/GuildVisitsGate';
import {
	mapGuildEmojiToResponse,
	mapGuildRoleToResponse,
	mapGuildStickerToResponse,
	mapGuildToGuildResponse,
} from '@app/api/guild/GuildModel';
import type {GuildService} from '@app/api/guild/services/GuildService';
import {maskChannelResponseThreadBits} from '@app/api/guild/services/ThreadPermissionBits';
import {assertNotBannedFromGuildVisit, endGuildVisit} from '@app/api/guild/visits/GuildVisitLifecycle';
import {guildVisitJoinTotal, guildVisitStartTotal} from '@app/api/guild/visits/GuildVisitMetrics';
import {
	computeVisitorChannelPermissionsFor,
	forgetGuildVisitRow,
	type GuildVisitorAccess,
	guildVisitRepository,
	isGuildUnavailable,
	resolveGuildVisitorAccess,
	toVisitorChannelModel,
} from '@app/api/guild/visits/GuildVisitorAccess';
import {emitActivity} from '@app/api/infrastructure/activity/ActivityEvents';
import type {VisitSource} from '@app/api/infrastructure/activity/Contract.generated';
import type {IGatewayService} from '@app/api/infrastructure/IGatewayService';
import type {UserCacheService} from '@app/api/infrastructure/UserCacheService';
import {parseInviteCodeList} from '@app/api/instance/AutoJoinInviteCodes';
import type {SingleCommunityService} from '@app/api/instance/SingleCommunityService';
import type {InviteService} from '@app/api/invite/InviteService';
import {Logger} from '@app/api/Logger';
import type {LimitConfigService} from '@app/api/limits/LimitConfigService';
import {resolveLimitSafe} from '@app/api/limits/LimitConfigUtils';
import {createLimitMatchContext} from '@app/api/limits/LimitMatchContextBuilder';
import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
import {
	getChannelRepository,
	getGuildDiscoveryRepository,
	getGuildRepository,
} from '@app/api/middleware/ServiceSingletons';
import type {Guild} from '@app/api/models/Guild';
import type {Invite} from '@app/api/models/Invite';
import type {User} from '@app/api/models/User';
import {assertAccountNotLimited} from '@app/api/user/AccountLimit';
import {assertCanVisit, assertTierAllows, getAccountTier, type TierContext} from '@app/api/user/AccountTier';
import {TierGatedActions} from '@fluxer/constants/src/AccountTierConstants';
import {ChannelTypes, InviteTypes, Permissions} from '@fluxer/constants/src/ChannelConstants';
import {DiscoveryApplicationStatus} from '@fluxer/constants/src/DiscoveryConstants';
import {GuildFeatures, GuildOperations, JoinSourceTypes} from '@fluxer/constants/src/GuildConstants';
import {
	GuildVisitEndReasons,
	type GuildVisitSource,
	GuildVisitSources,
} from '@fluxer/constants/src/GuildVisitConstants';
import {FeatureTemporarilyDisabledError} from '@fluxer/errors/src/domains/core/FeatureTemporarilyDisabledError';
import {GuildVisitNotFoundError} from '@fluxer/errors/src/domains/guild/GuildVisitNotFoundError';
import {GuildVisitsDisabledError} from '@fluxer/errors/src/domains/guild/GuildVisitsDisabledError';
import {UnknownGuildError} from '@fluxer/errors/src/domains/guild/UnknownGuildError';
import {InvitesDisabledError} from '@fluxer/errors/src/domains/invite/InvitesDisabledError';
import {UnknownInviteError} from '@fluxer/errors/src/domains/invite/UnknownInviteError';
import {DEFAULT_STOCK_LIMITS} from '@fluxer/limits/src/LimitDefaults';
import type {ChannelResponse} from '@fluxer/schema/src/domains/channel/ChannelSchemas';
import type {GuildResponse} from '@fluxer/schema/src/domains/guild/GuildResponseSchemas';
import type {GuildVisitResponse, GuildVisitStartResponse} from '@fluxer/schema/src/domains/guild/GuildVisitSchemas';

interface VisitStartContext {
	user: User;
	ip: string | null;
}

interface VisitAuthorization {
	guild: Guild;
	source: GuildVisitSource;
	invite: Invite | null;
}

function mapGuildVisitToResponse(row: GuildVisitRow): GuildVisitResponse {
	return {
		guild_id: row.guild_id.toString(),
		source: row.source as GuildVisitResponse['source'],
		started_at: row.started_at.toISOString(),
		opened_at: row.opened_at.toISOString(),
	};
}

function activitySource(source: GuildVisitSource): VisitSource {
	switch (source) {
		case GuildVisitSources.INVITE:
			return 'invite';
		case GuildVisitSources.VANITY_URL:
			return 'vanity';
		case GuildVisitSources.DISCOVERY:
			return 'discovery';
		case GuildVisitSources.OPERATOR:
			return 'operator';
	}
}

export function maxGuildVisitsFor(user: User, limitConfigService: LimitConfigService): number {
	const cap = resolveLimitSafe(
		limitConfigService.getConfigSnapshot(),
		createLimitMatchContext({user}),
		'max_guild_visits',
		DEFAULT_STOCK_LIMITS.max_guild_visits,
	);
	return getAccountTier(user) === 'verified' ? cap : Math.max(1, Math.floor(cap / 2));
}

export class GuildVisitService {
	constructor(
		private readonly gatewayService: IGatewayService,
		private readonly guildService: GuildService,
		private readonly inviteService: InviteService,
		private readonly singleCommunityService: SingleCommunityService,
		private readonly limitConfigService: LimitConfigService,
		private readonly userCacheService: UserCacheService,
	) {}

	async startFromInvite(params: VisitStartContext & {code: string}): Promise<GuildVisitStartResponse> {
		if (!userGuildVisitsActive(params.user.id)) throw new UnknownInviteError();
		const invite = await this.inviteService.findInvite(createInviteCode(params.code));
		if (!invite || invite.type !== InviteTypes.GUILD || !invite.guildId) throw new UnknownInviteError();
		const guild = await this.guildService.data.operations.getGuildSystem(invite.guildId);
		const vanityCode = guild.vanityUrlCode ? vanityCodeToInviteCode(guild.vanityUrlCode) : null;
		const source = invite.code === vanityCode ? GuildVisitSources.VANITY_URL : GuildVisitSources.INVITE;
		return this.start(params, {guild, source, invite});
	}

	async startFromDiscovery(params: VisitStartContext & {guildId: GuildID}): Promise<GuildVisitStartResponse> {
		if (!userGuildVisitsActive(params.user.id)) throw new UnknownGuildError();
		const status = await getGuildDiscoveryRepository().findByGuildId(params.guildId);
		if (status?.status !== DiscoveryApplicationStatus.APPROVED) throw new UnknownGuildError();
		const guild = await this.guildService.data.operations.getGuildSystem(params.guildId);
		return this.start(params, {guild, source: GuildVisitSources.DISCOVERY, invite: null});
	}

	async startForOperator(params: VisitStartContext & {code: string | null}): Promise<GuildVisitStartResponse | null> {
		if (!userGuildVisitsActive(params.user.id)) return null;
		let guildId: GuildID | null;
		let invite: Invite | null = null;
		if (params.code === null) {
			guildId = await this.singleCommunityService.getStockCommunityId();
		} else {
			invite = await this.inviteService.findInvite(createInviteCode(params.code));
			guildId = invite?.type === InviteTypes.GUILD ? invite.guildId : null;
		}
		if (guildId === null) return null;
		const guild = await this.guildService.data.operations.getGuildSystem(guildId);
		return this.start(params, {guild, source: GuildVisitSources.OPERATOR, invite});
	}

	private async start(context: VisitStartContext, auth: VisitAuthorization): Promise<GuildVisitStartResponse> {
		const {user, ip} = context;
		const {guild, source, invite} = auth;
		const guildId = guild.id;
		const viaInvite = source === GuildVisitSources.INVITE || source === GuildVisitSources.VANITY_URL;
		if (viaInvite && (guild.disabledOperations & GuildOperations.INSTANT_INVITES) !== 0) {
			throw new FeatureTemporarilyDisabledError();
		}
		if (source !== GuildVisitSources.OPERATOR && guild.features.has(GuildFeatures.INVITES_DISABLED)) {
			throw new InvitesDisabledError();
		}
		if (await this.gatewayService.hasGuildMember({guildId, userId: user.id})) {
			return {guild_id: guildId.toString(), member: true, visit: null};
		}
		if (isGuildUnavailable(guild)) throw new UnknownGuildError();
		if (source !== GuildVisitSources.OPERATOR && !guild.features.has(GuildFeatures.VISITS_ENABLED)) {
			throw new GuildVisitsDisabledError();
		}
		assertCanVisit(user, guild);
		assertAccountNotLimited(user);
		await assertNotBannedFromGuildVisit({guildId, user, ip});
		const repository = guildVisitRepository();
		const now = new Date();
		const visits = await repository.list(user.id);
		const existing = visits.find((row) => row.guild_id === guildId);
		if (existing) {
			forgetGuildVisitRow(user.id, guildId);
			const touched = await repository.touch(existing, now);
			await this.gatewayService.startVisit({
				userId: user.id,
				guildId,
				operator: existing.source === GuildVisitSources.OPERATOR,
			});
			return {guild_id: guildId.toString(), member: false, visit: mapGuildVisitToResponse(touched)};
		}
		if (invite && invite.maxUses > 0 && invite.uses >= invite.maxUses) throw new UnknownInviteError();
		await this.makeRoomForVisit(user, visits);
		const rowDetails = {
			user_id: user.id,
			guild_id: guildId,
			source,
			invite_code: viaInvite && invite ? invite.code : null,
		};
		let expiresAt: Date | null = null;
		if (viaInvite && invite) {
			expiresAt = invite.maxAge > 0 ? new Date(invite.createdAt.getTime() + invite.maxAge * 1000) : null;
		}
		const row: GuildVisitRow = {
			...rowDetails,
			invite_expires_at: expiresAt,
			started_at: now,
			opened_at: now,
		};
		if (!(await repository.upsert(row, now))) throw new UnknownInviteError();
		forgetGuildVisitRow(user.id, guildId);
		await this.gatewayService.startVisit({userId: user.id, guildId, operator: source === GuildVisitSources.OPERATOR});
		const tier = getAccountTier(user);
		guildVisitStartTotal.inc(`source="${activitySource(source)}",tier="${tier}"`);
		void emitActivity('guild_visit_started', user.id.toString(), {
			user_id: user.id.toString(),
			guild_id: guildId.toString(),
			source: activitySource(source),
			tier,
		});
		return {guild_id: guildId.toString(), member: false, visit: mapGuildVisitToResponse(row)};
	}

	private async makeRoomForVisit(user: User, visits: Array<GuildVisitRow>): Promise<void> {
		const cap = maxGuildVisitsFor(user, this.limitConfigService);
		const ordered = [...visits].sort((left, right) => left.opened_at.getTime() - right.opened_at.getTime());
		let overflow = ordered.length - cap + 1;
		for (const row of ordered) {
			if (overflow <= 0) break;
			await endGuildVisit({
				userId: user.id,
				guildId: row.guild_id,
				reason: GuildVisitEndReasons.REPLACED,
				gateway: this.gatewayService,
			});
			overflow--;
		}
	}

	async listOwn(userId: UserID): Promise<Array<GuildVisitResponse>> {
		if (!userGuildVisitsActive(userId)) return [];
		const now = Date.now();
		const rows = await guildVisitRepository().list(userId);
		return rows
			.filter((row) => row.invite_expires_at === null || row.invite_expires_at.getTime() > now)
			.sort((left, right) => right.opened_at.getTime() - left.opened_at.getTime())
			.map(mapGuildVisitToResponse);
	}

	async leave(userId: UserID, guildId: GuildID): Promise<void> {
		const row = await guildVisitRepository().get(userId, guildId);
		if (!row) {
			await this.endLiveVisitOnly(userId, guildId);
			return;
		}
		await endGuildVisit({userId, guildId, reason: GuildVisitEndReasons.LEFT, gateway: this.gatewayService});
	}

	async join(params: {
		user: User;
		guildId: GuildID;
		tierContext: TierContext;
		requestCache: RequestCache;
		ip?: string | null;
	}): Promise<GuildResponse> {
		const {user, guildId, tierContext} = params;
		const row = userGuildVisitsActive(user.id) ? await guildVisitRepository().get(user.id, guildId) : null;
		if (!row) throw new GuildVisitNotFoundError();
		if (await this.gatewayService.hasGuildMember({guildId, userId: user.id})) {
			await endGuildVisit({userId: user.id, guildId, reason: GuildVisitEndReasons.JOINED, notify: false});
			return mapGuildToGuildResponse(await this.guildService.data.operations.getGuildSystem(guildId));
		}
		assertTierAllows(user, TierGatedActions.GUILD_JOIN, tierContext);
		switch (row.source) {
			case GuildVisitSources.INVITE:
			case GuildVisitSources.VANITY_URL:
				await this.joinThroughInvite(row, params);
				break;
			case GuildVisitSources.DISCOVERY:
				await this.joinThroughDiscovery(row, params);
				break;
			default:
				await this.joinAsOperatorVisit(row, params);
		}
		guildVisitJoinTotal.inc(`source="${activitySource(row.source as GuildVisitSource)}"`);
		return mapGuildToGuildResponse(await this.guildService.data.operations.getGuildSystem(guildId));
	}

	private async joinThroughInvite(
		row: GuildVisitRow,
		params: {user: User; tierContext: TierContext; requestCache: RequestCache; ip?: string | null},
	): Promise<void> {
		const invite = row.invite_code ? await this.inviteService.findInvite(createInviteCode(row.invite_code)) : null;
		if (!invite || invite.guildId !== row.guild_id) {
			await endGuildVisit({
				userId: params.user.id,
				guildId: row.guild_id,
				reason: GuildVisitEndReasons.INVITE_REVOKED,
				gateway: this.gatewayService,
			});
			throw new UnknownInviteError();
		}
		await this.inviteService.acceptInvite({
			userId: params.user.id,
			inviteCode: invite.code,
			requestCache: params.requestCache,
			tierContext: params.tierContext,
			ip: params.ip,
		});
	}

	private async joinThroughDiscovery(
		row: GuildVisitRow,
		params: {user: User; tierContext: TierContext; requestCache: RequestCache; ip?: string | null},
	): Promise<void> {
		const status = await getGuildDiscoveryRepository().findByGuildId(row.guild_id);
		if (status?.status !== DiscoveryApplicationStatus.APPROVED) {
			await endGuildVisit({
				userId: params.user.id,
				guildId: row.guild_id,
				reason: GuildVisitEndReasons.DISABLED,
				gateway: this.gatewayService,
			});
			throw new UnknownGuildError();
		}
		const guild = await this.guildService.data.operations.getGuildSystem(row.guild_id);
		if (guild.features.has(GuildFeatures.INVITES_DISABLED)) throw new InvitesDisabledError();
		await this.guildService.members.addUserToGuild({
			userId: params.user.id,
			guildId: row.guild_id,
			sendJoinMessage: true,
			joinSourceType: JoinSourceTypes.DISCOVERY,
			requestCache: params.requestCache,
			tierContext: params.tierContext,
			ip: params.ip,
		});
	}

	private async findOperatorInvite(guildId: GuildID): Promise<Invite | null> {
		for (const code of parseInviteCodeList(Config.instance.autoJoinInviteCode)) {
			const invite = await this.inviteService.findInvite(createInviteCode(code));
			if (invite?.guildId === guildId) return invite;
		}
		return null;
	}

	private async joinAsOperatorVisit(
		row: GuildVisitRow,
		params: {user: User; tierContext: TierContext; requestCache: RequestCache; ip?: string | null},
	): Promise<void> {
		if ((await this.singleCommunityService.getStockCommunityId()) !== row.guild_id) {
			const invite = await this.findOperatorInvite(row.guild_id);
			if (invite) {
				await this.inviteService.acceptInvite({
					userId: params.user.id,
					inviteCode: invite.code,
					requestCache: params.requestCache,
					tierContext: params.tierContext,
					ip: params.ip,
				});
				return;
			}
			await endGuildVisit({
				userId: params.user.id,
				guildId: row.guild_id,
				reason: GuildVisitEndReasons.DISABLED,
				gateway: this.gatewayService,
			});
			throw new UnknownGuildError();
		}
		await this.guildService.members.addUserToGuild({
			userId: params.user.id,
			guildId: row.guild_id,
			skipGuildLimitCheck: true,
			joinSourceType: JoinSourceTypes.ADMIN_FORCE_ADD,
			requestCache: params.requestCache,
			tierContext: params.tierContext,
			ip: params.ip,
		});
	}

	async listChannelsForVisitor(params: {
		userId: UserID;
		guildId: GuildID;
		viewer: ThreadViewer;
		requestCache: RequestCache;
	}): Promise<Array<ChannelResponse> | null> {
		const access = await resolveGuildVisitorAccess({userId: params.userId, guildId: params.guildId});
		if (!access) return null;
		return this.visitorChannels(access, params);
	}

	private async visitorChannels(
		access: GuildVisitorAccess,
		params: {guildId: GuildID; viewer: ThreadViewer; requestCache: RequestCache},
	): Promise<Array<ChannelResponse>> {
		const channelRepository = getChannelRepository();
		const channels = await channelRepository.channelData.listGuildChannels(params.guildId, 'enrolled');
		const byId = new Map(channels.map((channel) => [channel.id, channel]));
		const visible = channels.filter((channel) => {
			if (channel.isThreadOnly() && !viewerActive(params.viewer, params.guildId)) return false;
			const parent =
				channel.parentId && channel.type !== ChannelTypes.GUILD_CATEGORY ? (byId.get(channel.parentId) ?? null) : null;
			const permissions = computeVisitorChannelPermissionsFor({access, channel, parent});
			return (permissions & Permissions.VIEW_CHANNEL) === Permissions.VIEW_CHANNEL;
		});
		const stripped = visible.map(toVisitorChannelModel);
		const responses = await Promise.all(
			stripped.map((channel) =>
				mapChannelToResponse({
					channel,
					currentUserId: null,
					userCacheService: this.userCacheService,
					requestCache: params.requestCache,
				}),
			),
		);
		return maskChannelResponseThreadBits(
			params.guildId,
			params.viewer,
			await withThreadParentFieldsMany(channelRepository.threads, params.guildId, stripped, responses, params.viewer),
		);
	}

	async getGuildForVisitor(params: {
		userId: UserID;
		guildId: GuildID;
		viewer: ThreadViewer;
		requestCache: RequestCache;
	}): Promise<GuildResponse | null> {
		const access = await resolveGuildVisitorAccess({userId: params.userId, guildId: params.guildId});
		if (!access) return null;
		const guildRepository = getGuildRepository();
		const [roles, emojis, stickers, channels] = await Promise.all([
			guildRepository.listRoles(params.guildId),
			guildRepository.listEmojis(params.guildId),
			guildRepository.listStickers(params.guildId),
			this.visitorChannels(access, params),
		]);
		return {
			...mapGuildToGuildResponse(access.view.guild),
			roles: roles.map(mapGuildRoleToResponse),
			emojis: emojis.map(mapGuildEmojiToResponse),
			stickers: stickers.map(mapGuildStickerToResponse),
			channels,
			member_count: access.view.guild.memberCount,
			visiting: true,
		};
	}

	private async endLiveVisitOnly(userId: UserID, guildId: GuildID): Promise<void> {
		try {
			await this.gatewayService.endVisit({userId, guildId});
		} catch (error) {
			Logger.warn(
				{userId: userId.toString(), guildId: guildId.toString(), error},
				'Failed to end a visit on the gateway',
			);
		}
	}
}