feat(experiments): target rollouts by guild and premium status (#3012)

fluxer_api/src/api/experiment/ExperimentController.ts

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 import {createHash} from 'node:crypto';
+import {resolveExperimentTargeting} from '@app/api/experiment/ExperimentTargeting';
 import {LoginRequired} from '@app/api/middleware/AuthMiddleware';
 import {RateLimitMiddleware} from '@app/api/middleware/RateLimitMiddleware';
 import {OpenAPI} from '@app/api/middleware/ResponseTypeMiddleware';
@@ -39,15 +40,22 @@ export function ExperimentController(app: HonoApp) {
 					instanceConfigRepository.getAltchaCaptchaConfig(),
 					instanceConfigRepository.getProfileTimezoneConfig(),
 				]);
-			const userId = ctx.get('user').id.toString();
+			const user = ctx.get('user');
+			const userId = user.id.toString();
+			const targeting = await resolveExperimentTargeting(user, [
+				voiceConfig,
+				domainMigrationConfig,
+				altchaCaptchaConfig,
+				profileTimezoneConfig,
+			]);
 			const body: ExperimentAssignmentsResponse = {
 				poll_interval_seconds: delivery.poll_interval_seconds,
 				poll_jitter_percent: delivery.poll_jitter_percent,
 				assignments: {
-					voice_noise_suppression: resolveVoiceNoiseSuppressionAssignment(voiceConfig, userId),
-					domain_migration: resolveDomainMigrationAssignment(domainMigrationConfig, userId),
-					altcha_captcha: resolveAltchaCaptchaAssignment(altchaCaptchaConfig, userId),
-					profile_timezone: resolveProfileTimezoneAssignment(profileTimezoneConfig, userId),
+					voice_noise_suppression: resolveVoiceNoiseSuppressionAssignment(voiceConfig, userId, targeting),
+					domain_migration: resolveDomainMigrationAssignment(domainMigrationConfig, userId, targeting),
+					altcha_captcha: resolveAltchaCaptchaAssignment(altchaCaptchaConfig, userId, targeting),
+					profile_timezone: resolveProfileTimezoneAssignment(profileTimezoneConfig, userId, targeting),
 				},
 			};
 			const etag = `"${createHash('sha256').update(JSON.stringify(body)).digest('hex')}"`;

fluxer_api/src/api/experiment/ExperimentTargeting.ts

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {getUserRepository} from '@app/api/middleware/ServiceSingletons';
+import type {User} from '@app/api/models/User';
+import type {ExperimentTargeting} from '@fluxer/schema/src/domains/experiment/ExperimentBucket';
+
+interface TargetableExperimentConfig {
+	readonly enabled: boolean;
+	readonly included_guild_ids: ReadonlyArray<string>;
+}
+
+const NO_GUILDS: ReadonlySet<string> = new Set();
+
+export const ANONYMOUS_EXPERIMENT_TARGETING: ExperimentTargeting = {
+	memberGuildIds: NO_GUILDS,
+	premium: false,
+};
+
+export async function resolveExperimentTargeting(
+	user: User,
+	configs: ReadonlyArray<TargetableExperimentConfig>,
+): Promise<ExperimentTargeting> {
+	const needsGuilds = configs.some((config) => config.enabled && config.included_guild_ids.length > 0);
+	const memberGuildIds = needsGuilds
+		? new Set((await getUserRepository().getUserGuildIds(user.id)).map((guildId) => guildId.toString()))
+		: NO_GUILDS;
+	return {memberGuildIds, premium: !user.isBot && user.isPremium()};
+}

fluxer_api/src/api/experiment/tests/ExperimentController.test.ts

@@ -1,11 +1,14 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 import {createTestAccount, setUserACLs} from '@app/api/auth/tests/AuthTestUtils';
+import {acceptInvite, createChannelInvite, createGuild, getChannel} from '@app/api/guild/tests/GuildTestUtils';
 import {getInstanceConfigRepository} from '@app/api/middleware/ServiceSingletons';
 import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
 import {HTTP_STATUS} from '@app/api/test/TestConstants';
 import {createBuilder, createBuilderWithoutAuth} from '@app/api/test/TestRequestBuilder';
+import {grantPremium} from '@app/api/user/tests/UserTestUtils';
 import {AdminACLs} from '@fluxer/constants/src/AdminACLs';
+import {UserPremiumTypes} from '@fluxer/constants/src/UserConstants';
 import {
 	DEFAULT_ALTCHA_CAPTCHA_CONFIG,
 	INERT_ALTCHA_CAPTCHA_ASSIGNMENT,
@@ -250,6 +253,109 @@ describe('GET /experiments', () => {
 		expect(body.assignments.profile_timezone).toEqual({enabled: true});
 	});
 
+	it('enrols members of an included guild in every experiment and leaves everyone else out', async () => {
+		const owner = await createTestAccount(harness);
+		const member = await createTestAccount(harness);
+		const outsider = await createTestAccount(harness);
+		const guild = await createGuild(harness, owner.token, 'Experiment Guild');
+		const systemChannel = await getChannel(harness, owner.token, guild.system_channel_id!);
+		const invite = await createChannelInvite(harness, owner.token, systemChannel.id);
+		await acceptInvite(harness, member.token, invite.code);
+		const repository = getInstanceConfigRepository();
+		await repository.setVoiceNoiseSuppressionConfig({
+			...DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
+			enabled: true,
+			included_guild_ids: [guild.id],
+		});
+		await repository.setDomainMigrationConfig({
+			...DEFAULT_DOMAIN_MIGRATION_CONFIG,
+			enabled: true,
+			included_guild_ids: [guild.id],
+		});
+		await repository.setAltchaCaptchaConfig({
+			...DEFAULT_ALTCHA_CAPTCHA_CONFIG,
+			enabled: true,
+			included_guild_ids: [guild.id],
+		});
+		await repository.setProfileTimezoneConfig({
+			...DEFAULT_PROFILE_TIMEZONE_CONFIG,
+			enabled: true,
+			included_guild_ids: [guild.id],
+		});
+
+		const memberBody = await createBuilder<ExperimentAssignmentsResponse>(harness, member.token)
+			.get(ENDPOINT)
+			.execute();
+		expect(memberBody.assignments.voice_noise_suppression).toMatchObject({user_targeted: true, source: 'user_rule'});
+		expect(memberBody.assignments.domain_migration).toEqual({enabled: true});
+		expect(memberBody.assignments.altcha_captcha).toEqual({enabled: true});
+		expect(memberBody.assignments.profile_timezone).toEqual({enabled: true});
+
+		const outsiderBody = await createBuilder<ExperimentAssignmentsResponse>(harness, outsider.token)
+			.get(ENDPOINT)
+			.execute();
+		expect(outsiderBody.assignments.voice_noise_suppression).toMatchObject({user_targeted: false, source: null});
+		expect(outsiderBody.assignments.domain_migration).toEqual({enabled: false});
+		expect(outsiderBody.assignments.altcha_captcha).toEqual({enabled: false});
+		expect(outsiderBody.assignments.profile_timezone).toEqual({enabled: false});
+	});
+
+	it('enrols premium users, subscription and lifetime alike, when the switch is on', async () => {
+		const subscriber = await createTestAccount(harness);
+		const visionary = await createTestAccount(harness);
+		const free = await createTestAccount(harness);
+		await grantPremium(harness, subscriber.userId, UserPremiumTypes.SUBSCRIPTION);
+		await grantPremium(harness, visionary.userId, UserPremiumTypes.LIFETIME);
+		await getInstanceConfigRepository().setProfileTimezoneConfig({
+			...DEFAULT_PROFILE_TIMEZONE_CONFIG,
+			enabled: true,
+			include_premium_users: true,
+		});
+		for (const [account, expected] of [
+			[subscriber, true],
+			[visionary, true],
+			[free, false],
+		] as const) {
+			const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
+			expect(body.assignments.profile_timezone).toEqual({enabled: expected});
+		}
+	});
+
+	it('stores the guild ids and premium switch an admin sets for each experiment', async () => {
+		const admin = await setUserACLs(harness, await createTestAccount(harness), [
+			AdminACLs.AUTHENTICATE,
+			AdminACLs.INSTANCE_CONFIG_VIEW,
+			AdminACLs.INSTANCE_CONFIG_UPDATE,
+		]);
+		const guildIds = ['1500000000000000001', '1500000000000000002'];
+		const body = await createBuilder<
+			Record<
+				'voice_noise_suppression' | 'domain_migration' | 'altcha_captcha' | 'profile_timezone',
+				{included_guild_ids: Array<string>; include_premium_users: boolean}
+			>
+		>(harness, admin.token)
+			.patch('/admin/instance/config')
+			.body({
+				voice_noise_suppression: {included_guild_ids: guildIds, include_premium_users: true},
+				domain_migration: {included_guild_ids: guildIds, include_premium_users: true},
+				altcha_captcha: {included_guild_ids: guildIds, include_premium_users: true},
+				profile_timezone: {included_guild_ids: guildIds, include_premium_users: true},
+			})
+			.execute();
+		expect(body.voice_noise_suppression.included_guild_ids).toEqual(guildIds);
+		expect(body.domain_migration.included_guild_ids).toEqual(guildIds);
+		expect(body.altcha_captcha.included_guild_ids).toEqual(guildIds);
+		expect(body.profile_timezone.included_guild_ids).toEqual(guildIds);
+		for (const section of [
+			body.voice_noise_suppression,
+			body.domain_migration,
+			body.altcha_captcha,
+			body.profile_timezone,
+		]) {
+			expect(section.include_premium_users).toBe(true);
+		}
+	});
+
 	it('serves the delivery cadence from the delivery config and not from the voice config', async () => {
 		const account = await createTestAccount(harness);
 		await getInstanceConfigRepository().setExperimentDeliveryConfig({

fluxer_api/src/api/middleware/CaptchaMiddleware.ts

@@ -2,6 +2,7 @@
 
 import {createHmac} from 'node:crypto';
 import {Config} from '@app/api/Config';
+import {ANONYMOUS_EXPERIMENT_TARGETING, resolveExperimentTargeting} from '@app/api/experiment/ExperimentTargeting';
 import type {InstanceCaptchaEffectiveConfig} from '@app/api/instance/InstanceConfigRepository';
 import {Logger} from '@app/api/Logger';
 import {getKVClient} from '@app/api/middleware/ServiceRegistry';
@@ -45,7 +46,8 @@ async function altchaChallengeData(altcha: AltchaProvider | null): Promise<Recor
 
 async function resolveAltchaProvider(ctx: Context<HonoEnv>, user: User | undefined): Promise<AltchaProvider | null> {
 	const config = await ctx.get('instanceConfigRepository').getAltchaCaptchaConfig();
-	if (!altchaCaptchaAppliesTo(config, user ? user.id.toString() : null)) return null;
+	const targeting = user ? await resolveExperimentTargeting(user, [config]) : ANONYMOUS_EXPERIMENT_TARGETING;
+	if (!altchaCaptchaAppliesTo(config, user ? user.id.toString() : null, targeting)) return null;
 	return createAltchaProvider(config);
 }
 

fluxer_api/src/api/user/UserHelpers.ts

@@ -2,6 +2,7 @@
 
 import {Config} from '@app/api/Config';
 import type {UserRow} from '@app/api/database/types/UserTypes';
+import {resolveExperimentTargeting} from '@app/api/experiment/ExperimentTargeting';
 import {getCachedInstancePremiumMode} from '@app/api/limits/InstancePremiumModeCache';
 import {getInstanceConfigRepository} from '@app/api/middleware/ServiceSingletons';
 import type {User} from '@app/api/models/User';
@@ -291,7 +292,8 @@ export function isBugHunterBotUser(user: Pick<User, 'flags' | 'isBot'>): boolean
 	return user.isBot && (user.flags & UserFlags.BUG_HUNTER) !== 0n;
 }
 
-export async function canUseProfileTimezone(user: Pick<User, 'id'>): Promise<boolean> {
+export async function canUseProfileTimezone(user: User): Promise<boolean> {
 	const config = await getInstanceConfigRepository().getProfileTimezoneConfig();
-	return resolveProfileTimezoneAssignment(config, user.id.toString()).enabled;
+	const targeting = await resolveExperimentTargeting(user, [config]);
+	return resolveProfileTimezoneAssignment(config, user.id.toString(), targeting).enabled;
 }

fluxer_api/src/api/user/tests/UserProfileTimezoneVisibility.test.ts

@@ -168,6 +168,21 @@ describe('User Profile Timezone Visibility', () => {
 		const updated = await updateProfileTimezone(harness, targetAccount.token, {timezone: TEST_TIMEZONE});
 		expect(updated.timezone).toBeNull();
 	});
+	it('lets members of an included guild set and show a timezone', async () => {
+		const targetAccount = await createTestAccount(harness);
+		const viewerAccount = await createTestAccount(harness);
+		const guild = await createGuild(harness, targetAccount.token, 'Timezone Rollout Guild');
+		await getInstanceConfigRepository().setProfileTimezoneConfig({
+			...DEFAULT_PROFILE_TIMEZONE_CONFIG,
+			enabled: true,
+			included_guild_ids: [guild.id],
+		});
+		const updated = await updateProfileTimezone(harness, targetAccount.token, {timezone: TEST_TIMEZONE});
+		expect(updated.timezone).toBe(TEST_TIMEZONE);
+		await createFriendship(harness, targetAccount, viewerAccount);
+		const profile = await getUserProfile(harness, viewerAccount.token, targetAccount.userId);
+		expect(profile.timezone_offset).toBe(TEST_TIMEZONE_OFFSET);
+	});
 	it('hides stored profile timezone after the user leaves the experiment', async () => {
 		const targetAccount = await createTestAccount(harness);
 		const viewerAccount = await createTestAccount(harness);