perf(push): batch badge count invalidation per mention chunk (#2178)

fluxer_api/src/api/infrastructure/GatewayService.ts

@@ -32,6 +32,8 @@ import type {
 	GatewayVoiceStateEntry,
 } from './IGatewayService';
 
+const PUSH_BADGE_COUNT_BATCH_SIZE = 100;
+
 const GATEWAY_ERROR_TO_DOMAIN_ERROR: Record<string, () => Error> = {
 	[GatewayRpcMethodErrorCodes.GUILD_NOT_FOUND]: () => new UnknownGuildError(),
 	[GatewayRpcMethodErrorCodes.FORBIDDEN]: () => new MissingPermissionsError(),
@@ -61,6 +63,10 @@ interface InvalidatePushBadgeCountParams {
 	userId: UserID;
 }
 
+interface InvalidatePushBadgeCountsParams {
+	userIds: Array<UserID>;
+}
+
 interface InvalidatePushSubscriptionsParams {
 	userId: UserID;
 }
@@ -578,6 +584,18 @@ export class GatewayService {
 		});
 	}
 
+	async invalidatePushBadgeCounts({userIds}: InvalidatePushBadgeCountsParams): Promise<void> {
+		const batches: Array<Array<UserID>> = [];
+		for (let index = 0; index < userIds.length; index += PUSH_BADGE_COUNT_BATCH_SIZE) {
+			batches.push(userIds.slice(index, index + PUSH_BADGE_COUNT_BATCH_SIZE));
+		}
+		await Promise.all(
+			batches.map((batch) =>
+				this.call('push.invalidate_badge_counts', {user_ids: batch.map((userId) => userId.toString())}),
+			),
+		);
+	}
+
 	async invalidatePushSubscriptions({userId}: InvalidatePushSubscriptionsParams): Promise<void> {
 		await this.call('push.invalidate_subscriptions', {
 			user_id: userId.toString(),

fluxer_api/src/api/infrastructure/IGatewayService.ts

@@ -282,6 +282,8 @@ export abstract class IGatewayService {
 
 	abstract invalidatePushBadgeCount(params: {userId: UserID}): Promise<void>;
 
+	abstract invalidatePushBadgeCounts(params: {userIds: Array<UserID>}): Promise<void>;
+
 	abstract invalidatePushSubscriptions(params: {userId: UserID}): Promise<void>;
 
 	abstract clearPushChannelNotifications(params: {

fluxer_api/src/api/read_state/ReadStateService.test.ts

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {describe, expect, it, vi} from 'vitest';
+import {type ChannelID, createChannelID, createMessageID, createUserID, type UserID} from '../BrandedTypes';
+import type {IGatewayService} from '../infrastructure/IGatewayService';
+import type {IReadStateRepository} from './IReadStateRepository';
+import {ReadStateService} from './ReadStateService';
+
+describe('ReadStateService.bulkIncrementMentionCounts', () => {
+	it('invalidates badge counts for touched users in a single bulk call', async () => {
+		const channelId = createChannelID(2n);
+		const messageId = createMessageID(3n);
+		const touched: Array<{userId: UserID; channelId: ChannelID}> = [
+			{userId: createUserID(10n), channelId},
+			{userId: createUserID(11n), channelId},
+			{userId: createUserID(10n), channelId: createChannelID(4n)},
+		];
+		const repository = {
+			bulkIncrementMentionCounts: vi.fn().mockResolvedValue(touched),
+		} as unknown as IReadStateRepository;
+		const invalidatePushBadgeCounts = vi.fn().mockResolvedValue(undefined);
+		const invalidatePushBadgeCount = vi.fn().mockResolvedValue(undefined);
+		const gatewayService = {
+			invalidatePushBadgeCounts,
+			invalidatePushBadgeCount,
+		} as unknown as IGatewayService;
+		const service = new ReadStateService(repository, gatewayService);
+
+		await service.bulkIncrementMentionCounts([
+			{userId: createUserID(10n), channelId, messageId},
+			{userId: createUserID(11n), channelId, messageId},
+			{userId: createUserID(12n), channelId, messageId},
+		]);
+
+		expect(invalidatePushBadgeCount).not.toHaveBeenCalled();
+		expect(invalidatePushBadgeCounts).toHaveBeenCalledTimes(1);
+		expect(invalidatePushBadgeCounts).toHaveBeenCalledWith({userIds: [createUserID(10n), createUserID(11n)]});
+	});
+
+	it('skips the bulk call when no read state was touched', async () => {
+		const repository = {
+			bulkIncrementMentionCounts: vi.fn().mockResolvedValue([]),
+		} as unknown as IReadStateRepository;
+		const invalidatePushBadgeCounts = vi.fn().mockResolvedValue(undefined);
+		const gatewayService = {invalidatePushBadgeCounts} as unknown as IGatewayService;
+		const service = new ReadStateService(repository, gatewayService);
+
+		await service.bulkIncrementMentionCounts([
+			{userId: createUserID(10n), channelId: createChannelID(2n), messageId: createMessageID(3n)},
+		]);
+
+		expect(invalidatePushBadgeCounts).not.toHaveBeenCalled();
+	});
+});

fluxer_api/src/api/read_state/ReadStateService.ts

@@ -171,14 +171,13 @@ export class ReadStateService {
 		try {
 			const appliedUpdates = await this.repository.bulkIncrementMentionCounts(updates);
 			const uniqueUserIds = Array.from(new Set(appliedUpdates.map((update) => update.userId)));
-			await Promise.all(
-				uniqueUserIds.map((userId) =>
-					this.gatewayService.invalidatePushBadgeCount({userId}).catch((error) => {
-						Logger.error({userId: userId.toString(), error}, 'Failed to invalidate push badge count');
-						return null;
-					}),
-				),
-			);
+			if (uniqueUserIds.length === 0) {
+				return;
+			}
+			await this.gatewayService.invalidatePushBadgeCounts({userIds: uniqueUserIds}).catch((error) => {
+				Logger.error({userCount: uniqueUserIds.length, error}, 'Failed to invalidate push badge counts');
+				return null;
+			});
 		} catch (error) {
 			Logger.error({error}, 'Bulk increment mention counts failed');
 			throw error;

fluxer_api/src/api/test/NoopGatewayService.ts

@@ -797,6 +797,8 @@ export class NoopGatewayService extends IGatewayService {
 
 	async invalidatePushBadgeCount(_params: {userId: UserID}): Promise<void> {}
 
+	async invalidatePushBadgeCounts(_params: {userIds: Array<UserID>}): Promise<void> {}
+
 	async invalidatePushSubscriptions(_params: {userId: UserID}): Promise<void> {}
 
 	async clearPushChannelNotifications(_params: {