Skip to content

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

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

import {createGuildID, type GuildID, type UserID} from '@app/api/BrandedTypes';
import {SYSTEM_USER_ID} from '@app/api/constants/Core';
import type {GuildOperationsService} from '@app/api/guild/services/data/GuildOperationsService';
import type {GuildMemberService} from '@app/api/guild/services/GuildMemberService';
import {
	type InstanceConfigRepository,
	REGISTRATION_PENDING_APPROVAL_TRAIT,
	REGISTRATION_REJECTED_TRAIT,
} from '@app/api/instance/InstanceConfigRepository';
import {Logger} from '@app/api/Logger';
import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
import type {User} from '@app/api/models/User';
import {JoinSourceTypes} from '@fluxer/constants/src/GuildConstants';
import {UserFlags} from '@fluxer/constants/src/UserConstants';
import {UnknownGuildError} from '@fluxer/errors/src/domains/guild/UnknownGuildError';

const INELIGIBLE_FLAGS = UserFlags.DELETED | UserFlags.SELF_DELETED | UserFlags.DISABLED;

export function canJoinSingleCommunity(user: User): boolean {
	return (
		user.id !== SYSTEM_USER_ID &&
		!user.isBot &&
		!user.isSystem &&
		(user.flags & INELIGIBLE_FLAGS) === 0n &&
		user.pendingDeletionAt === null &&
		!user.traits.has(REGISTRATION_PENDING_APPROVAL_TRAIT) &&
		!user.traits.has(REGISTRATION_REJECTED_TRAIT)
	);
}

export class SingleCommunityService {
	constructor(
		private readonly instanceConfigRepository: InstanceConfigRepository,
		private readonly guildOperations: GuildOperationsService,
		private readonly guildMemberService: GuildMemberService,
	) {}

	async getStockCommunityId(): Promise<GuildID | null> {
		const policy = await this.instanceConfigRepository.getInstancePolicyConfig();
		if (!policy.single_community_enabled || policy.single_community_guild_id === null) {
			return null;
		}
		return createGuildID(BigInt(policy.single_community_guild_id));
	}

	async joinStockCommunity(userId: UserID, requestCache: RequestCache): Promise<GuildID | null> {
		const guildId = await this.getStockCommunityId();
		if (guildId === null) {
			return null;
		}
		try {
			await this.guildMemberService.addUserToGuild({
				userId,
				guildId,
				skipGuildLimitCheck: true,
				skipAccountLimitCheck: true,
				joinSourceType: JoinSourceTypes.ADMIN_FORCE_ADD,
				requestCache,
			});
			return guildId;
		} catch (error) {
			Logger.warn(
				{userId: userId.toString(), guildId: guildId.toString(), error},
				'Failed to auto-join stock community',
			);
			return null;
		}
	}

	async ensureStockCommunity(params: {owner: User | null; name: string; guildId?: GuildID | null}): Promise<GuildID> {
		const policy = await this.instanceConfigRepository.getInstancePolicyConfig();
		const designatedGuildId = await this.findCommunity(params.guildId?.toString() ?? policy.single_community_guild_id);
		if (designatedGuildId != null) {
			await this.instanceConfigRepository.setInstancePolicyConfig({
				single_community_enabled: true,
				single_community_guild_id: designatedGuildId.toString(),
			});
			return designatedGuildId;
		}
		if (params.owner === null) {
			throw new UnknownGuildError();
		}
		return this.createStockCommunity({owner: params.owner, name: params.name});
	}

	async findCommunity(rawGuildId: string | null): Promise<GuildID | null> {
		if (rawGuildId === null) {
			return null;
		}
		const guildId = createGuildID(BigInt(rawGuildId));
		try {
			await this.guildOperations.getGuildSystem(guildId);
			return guildId;
		} catch (error) {
			if (error instanceof UnknownGuildError) return null;
			throw error;
		}
	}

	private async createStockCommunity(params: {owner: User; name: string}): Promise<GuildID> {
		const guild = await this.guildOperations.createGuild({user: params.owner, data: {name: params.name}});
		const guildId = createGuildID(BigInt(guild.id));
		await this.instanceConfigRepository.setInstancePolicyConfig({
			single_community_enabled: true,
			single_community_guild_id: guildId.toString(),
		});
		return guildId;
	}
}