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 {
	createInviteCode,
	createVanityURLCode,
	type GuildID,
	type UserID,
	vanityCodeToInviteCode,
} from '@app/api/BrandedTypes';
import type {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import type {GuildDataHelpers} from '@app/api/guild/services/data/GuildDataHelpers';
import {enqueueEndGuildVisitsForCode} from '@app/api/guild/visits/GuildVisitLifecycle';
import type {InviteRepository} from '@app/api/invite/InviteRepository';
import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
import {serializeGuildForAudit} from '@app/api/utils/AuditSerializationUtils';
import {AuditLogActionType} from '@fluxer/constants/src/AuditLogActionType';
import {Permissions} from '@fluxer/constants/src/ChannelConstants';
import {GuildFeatures} from '@fluxer/constants/src/GuildConstants';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
import {UnknownGuildError} from '@fluxer/errors/src/domains/guild/UnknownGuildError';
import type {GuildVanityURLResponse} from '@fluxer/schema/src/domains/guild/GuildResponseSchemas';

const VANITY_AUDIT_KEYS: ReadonlySet<string> = new Set(['vanity_url_code']);

export class GuildVanityService {
	constructor(
		private readonly guildRepository: GuildRepository,
		private readonly inviteRepository: InviteRepository,
		private readonly helpers: GuildDataHelpers,
	) {}

	async getVanityURL(params: {userId: UserID; guildId: GuildID}): Promise<GuildVanityURLResponse> {
		const {userId, guildId} = params;
		const {guildData, checkPermission} = await this.helpers.getGuildAuthenticated({userId, guildId});
		await checkPermission(Permissions.MANAGE_GUILD);
		if (!guildData) throw new UnknownGuildError();
		const vanityCodeString = guildData.vanity_url_code;
		if (!vanityCodeString) {
			return {code: null, uses: 0};
		}
		const vanityCode = createVanityURLCode(vanityCodeString);
		const invite = await this.inviteRepository.findUnique(vanityCodeToInviteCode(vanityCode));
		return {
			code: vanityCodeString,
			uses: invite?.uses ?? 0,
		};
	}

	async updateVanityURL(
		params: {
			userId: UserID;
			guildId: GuildID;
			code: string | null;
			requestCache: RequestCache;
		},
		auditLogReason?: string | null,
	): Promise<{
		code: string | null;
	}> {
		const {userId, guildId, code} = params;
		const {checkPermission} = await this.helpers.getGuildAuthenticated({userId, guildId});
		await checkPermission(Permissions.MANAGE_GUILD);
		const guild = await this.guildRepository.findUnique(guildId);
		if (!guild) throw new UnknownGuildError();
		const previousSnapshot = serializeGuildForAudit(guild);
		if (code && !guild.features.has(GuildFeatures.VANITY_URL)) {
			throw InputValidationError.fromCode('code', ValidationErrorCodes.VANITY_URL_REQUIRES_FEATURE);
		}
		if (code?.includes('fluxer')) {
			throw InputValidationError.fromCode('code', ValidationErrorCodes.VANITY_URL_CODE_CANNOT_CONTAIN_FLUXER);
		}
		if (code != null && guild.vanityUrlCode === code) {
			return {code};
		}
		if (code == null) {
			if (guild.vanityUrlCode != null) {
				const oldInvite = await this.inviteRepository.findUnique(vanityCodeToInviteCode(guild.vanityUrlCode));
				if (oldInvite) {
					await this.inviteRepository.releaseVanityInvite(oldInvite.code, guildId);
					await enqueueEndGuildVisitsForCode(guildId, oldInvite.code);
				}
				const updatedGuild = await this.guildRepository.upsertPartial(guildId, {vanity_url_code: null}, guild.toRow());
				await this.helpers.dispatchGuildUpdate(updatedGuild);
				await this.helpers.guildAuditLogService.record({
					guildId,
					userId,
					action: AuditLogActionType.GUILD_UPDATE,
					targetId: guildId,
					auditLogReason: auditLogReason ?? null,
					changes: this.helpers.computeGuildChanges(previousSnapshot, updatedGuild, VANITY_AUDIT_KEYS),
				});
				return {code: null};
			}
			return {code: null};
		}
		const claimed = await this.inviteRepository.claimVanityInvite(createInviteCode(code), guildId);
		if (claimed == null) {
			throw InputValidationError.fromCode('code', ValidationErrorCodes.VANITY_URL_CODE_ALREADY_TAKEN);
		}
		if (guild.vanityUrlCode != null) {
			const oldInvite = await this.inviteRepository.findUnique(vanityCodeToInviteCode(guild.vanityUrlCode));
			if (oldInvite) {
				await this.inviteRepository.releaseVanityInvite(oldInvite.code, guildId);
				await enqueueEndGuildVisitsForCode(guildId, oldInvite.code);
			}
		}
		const updatedGuild = await this.guildRepository.upsertPartial(
			guildId,
			{vanity_url_code: createVanityURLCode(code)},
			guild.toRow(),
		);
		await this.helpers.dispatchGuildUpdate(updatedGuild);
		await this.helpers.guildAuditLogService.record({
			guildId,
			userId,
			action: AuditLogActionType.GUILD_UPDATE,
			targetId: guildId,
			auditLogReason: auditLogReason ?? null,
			changes: this.helpers.computeGuildChanges(previousSnapshot, updatedGuild, VANITY_AUDIT_KEYS),
		});
		return {code};
	}
}