fix(admin): allow single community mode to be turned back on (#1684)

fluxer_api/src/api/admin/controllers/InstanceConfigAdminController.ts

@@ -91,7 +91,6 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
 		app_public: appPublic,
 		policy: {
 			single_community_enabled: policy.single_community_enabled,
-			single_community_locked: policy.single_community_locked,
 			single_community_guild_id: policy.single_community_guild_id,
 			direct_messages_disabled: policy.direct_messages_disabled,
 			direct_messages_locked: policy.direct_messages_locked,
@@ -551,20 +550,19 @@ async function applyInstancePolicyUpdate(
 		policy.single_community_enabled !== current.single_community_enabled
 	) {
 		if (policy.single_community_enabled) {
-			if (appPublic.setup.configured || current.single_community_locked) {
+			if (appPublic.setup.configured && current.single_community_guild_id == null) {
 				throw new InstancePolicyTransitionNotAllowedError();
 			}
 			const adminUser = await ctx.get('userRepository').findUnique(ctx.get('adminUserId'));
 			if (!adminUser) {
 				throw new InstancePolicyTransitionNotAllowedError();
 			}
-			await ctx.get('singleCommunityService').createStockCommunity({
+			await ctx.get('singleCommunityService').ensureStockCommunity({
 				owner: adminUser,
 				name: policy.single_community_name?.trim() || appPublic.branding.product_name,
 			});
 		} else {
 			patch.single_community_enabled = false;
-			patch.single_community_locked = true;
 		}
 	}
 	if (

fluxer_api/src/api/instance/InstanceConfigRepository.ts

@@ -77,7 +77,6 @@ export type InstancePremiumMode = 'mirror' | 'everyone';
 
 export interface InstancePolicyConfig {
 	single_community_enabled: boolean;
-	single_community_locked: boolean;
 	single_community_guild_id: string | null;
 	direct_messages_disabled: boolean;
 	direct_messages_locked: boolean;
@@ -396,7 +395,6 @@ function normalizeAppPublicConfig(value: unknown): InstanceAppPublicConfig {
 
 const DEFAULT_INSTANCE_POLICY_CONFIG: InstancePolicyConfig = {
 	single_community_enabled: false,
-	single_community_locked: false,
 	single_community_guild_id: null,
 	direct_messages_disabled: false,
 	direct_messages_locked: false,
@@ -420,7 +418,6 @@ function normalizeInstancePolicyConfig(value: unknown): InstancePolicyConfig {
 	}
 	return {
 		single_community_enabled: value.single_community_enabled === true,
-		single_community_locked: value.single_community_locked === true,
 		single_community_guild_id: normalizeNullableString(value.single_community_guild_id),
 		direct_messages_disabled: value.direct_messages_disabled === true,
 		direct_messages_locked: value.direct_messages_locked === true,

fluxer_api/src/api/instance/SingleCommunityService.ts

@@ -50,6 +50,37 @@ export class SingleCommunityService {
 		}
 	}
 
+	async ensureStockCommunity(params: {owner: User; name: string}): Promise<GuildID> {
+		const policy = await this.instanceConfigRepository.getInstancePolicyConfig();
+		const designatedGuildId = await this.findDesignatedGuild(policy.single_community_guild_id);
+		if (designatedGuildId != null) {
+			await this.instanceConfigRepository.setInstancePolicyConfig({
+				single_community_enabled: true,
+				single_community_guild_id: designatedGuildId.toString(),
+			});
+			return designatedGuildId;
+		}
+		return this.createStockCommunity(params);
+	}
+
+	private async findDesignatedGuild(rawGuildId: string | null): Promise<GuildID | null> {
+		if (!rawGuildId) {
+			return null;
+		}
+		let guildId: GuildID;
+		try {
+			guildId = createGuildID(BigInt(rawGuildId));
+		} catch {
+			return null;
+		}
+		try {
+			await this.guildDataService.getGuildSystem(guildId);
+			return guildId;
+		} catch {
+			return null;
+		}
+	}
+
 	async createStockCommunity(params: {owner: User; name: string}): Promise<GuildID> {
 		const guild = await this.guildDataService.createGuild({user: params.owner, data: {name: params.name}});
 		const guildId = createGuildID(BigInt(guild.id));

fluxer_api/src/api/instance/tests/SingleCommunityService.test.ts

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {describe, expect, it} from 'vitest';
+import type {User} from '../../models/User';
+import type {InstancePolicyConfig} from '../InstanceConfigRepository';
+import {SingleCommunityService} from '../SingleCommunityService';
+
+const EXISTING_GUILD_ID = '1234567890123456789';
+const OWNER = {id: 42n} as unknown as User;
+
+interface Harness {
+	service: SingleCommunityService;
+	written: Array<Partial<InstancePolicyConfig>>;
+	createdNames: Array<string>;
+}
+
+function createHarness(params: {designatedGuildId: string | null; designatedGuildExists: boolean}): Harness {
+	const written: Array<Partial<InstancePolicyConfig>> = [];
+	const createdNames: Array<string> = [];
+	let nextCreatedGuildId = 999n;
+	const instanceConfigRepository = {
+		getInstancePolicyConfig: async () => ({
+			single_community_enabled: false,
+			single_community_guild_id: params.designatedGuildId,
+		}),
+		setInstancePolicyConfig: async (patch: Partial<InstancePolicyConfig>) => {
+			written.push(patch);
+		},
+	};
+	const guildDataService = {
+		getGuildSystem: async () => {
+			if (!params.designatedGuildExists) {
+				throw new Error('unknown guild');
+			}
+			return {} as never;
+		},
+		createGuild: async ({data}: {data: {name: string}}) => {
+			createdNames.push(data.name);
+			nextCreatedGuildId += 1n;
+			return {id: nextCreatedGuildId.toString()} as never;
+		},
+	};
+	const service = new SingleCommunityService(
+		instanceConfigRepository as never,
+		guildDataService as never,
+		null as never,
+	);
+	return {service, written, createdNames};
+}
+
+describe('SingleCommunityService.ensureStockCommunity', () => {
+	it('reuses the designated community when it still exists', async () => {
+		const harness = createHarness({designatedGuildId: EXISTING_GUILD_ID, designatedGuildExists: true});
+		const guildId = await harness.service.ensureStockCommunity({owner: OWNER, name: 'Fluxer'});
+		expect(guildId.toString()).toBe(EXISTING_GUILD_ID);
+		expect(harness.createdNames).toEqual([]);
+		expect(harness.written).toEqual([{single_community_enabled: true, single_community_guild_id: EXISTING_GUILD_ID}]);
+	});
+
+	it('creates a fresh community when the designated one was deleted', async () => {
+		const harness = createHarness({designatedGuildId: EXISTING_GUILD_ID, designatedGuildExists: false});
+		const guildId = await harness.service.ensureStockCommunity({owner: OWNER, name: 'Fluxer'});
+		expect(guildId.toString()).not.toBe(EXISTING_GUILD_ID);
+		expect(harness.createdNames).toEqual(['Fluxer']);
+	});
+
+	it('creates a fresh community when the instance never designated one', async () => {
+		const harness = createHarness({designatedGuildId: null, designatedGuildExists: false});
+		await harness.service.ensureStockCommunity({owner: OWNER, name: 'Fluxer'});
+		expect(harness.createdNames).toEqual(['Fluxer']);
+	});
+
+	it('creates a fresh community when the stored guild id is not a snowflake', async () => {
+		const harness = createHarness({designatedGuildId: 'not-a-snowflake', designatedGuildExists: true});
+		await harness.service.ensureStockCommunity({owner: OWNER, name: 'Fluxer'});
+		expect(harness.createdNames).toEqual(['Fluxer']);
+	});
+});