fix: harden push notification delivery

Author: Arun-kushwaha007

apps/backend/src/notifications/notifications.service.spec.ts

@@ -1,7 +1,122 @@
 import { NotificationsService } from './notifications.service';
 
+jest.mock('ioredis', () =>
+  jest.fn().mockImplementation(() => ({
+    publish: jest.fn().mockResolvedValue(undefined),
+    quit: jest.fn().mockResolvedValue(undefined),
+    subscribe: jest.fn().mockResolvedValue(undefined),
+    on: jest.fn(),
+  })),
+);
+
 describe('NotificationsService', () => {
-  it('should be defined', () => {
-    expect(NotificationsService).toBeDefined();
+  function createService() {
+    const prisma: any = {
+      pushToken: {
+        findMany: jest.fn(),
+        deleteMany: jest.fn().mockResolvedValue({ count: 0 }),
+      },
+    };
+    const jobsQueueService: any = {
+      enqueueNotification: jest.fn().mockResolvedValue(undefined),
+    };
+    const config: any = {
+      redisUrl: 'redis://localhost:6379',
+    };
+    const service = new NotificationsService(config, prisma, jobsQueueService);
+
+    (service as any).publisher = {
+      publish: jest.fn().mockResolvedValue(undefined),
+      quit: jest.fn().mockResolvedValue(undefined),
+    };
+    (service as any).subscriber = {
+      subscribe: jest.fn().mockResolvedValue(undefined),
+      on: jest.fn(),
+      quit: jest.fn().mockResolvedValue(undefined),
+    };
+    (service as any).expo = {
+      chunkPushNotifications: jest.fn((messages) => [messages]),
+      sendPushNotificationsAsync: jest.fn(),
+    };
+
+    return { service, prisma, jobsQueueService };
+  }
+
+  it('queues a notification event and background job', async () => {
+    const { service, jobsQueueService } = createService();
+
+    await service.sendPushNotification(['user-1'], {
+      type: 'expense_created',
+      title: 'Expense added',
+      body: 'Dinner was added',
+    });
+
+    expect(jobsQueueService.enqueueNotification).toHaveBeenCalledWith({
+      userIds: ['user-1'],
+      payload: {
+        type: 'expense_created',
+        title: 'Expense added',
+        body: 'Dinner was added',
+      },
+    });
+  });
+
+  it('removes invalid Expo tokens after a push send response', async () => {
+    const { service, prisma } = createService();
+    prisma.pushToken.findMany.mockResolvedValue([
+      { token: 'ExponentPushToken[validToken]' },
+      { token: 'ExponentPushToken[invalidToken]' },
+    ]);
+    (service as any).expo.sendPushNotificationsAsync.mockResolvedValue([
+      { status: 'ok', id: 'ticket-1' },
+      { status: 'error', details: { error: 'DeviceNotRegistered' } },
+    ]);
+
+    await service.processQueuedNotification({
+      userIds: ['user-1'],
+      payload: {
+        type: 'group_invite',
+        title: 'Invite',
+        body: 'You were invited',
+      },
+    });
+
+    expect(prisma.pushToken.deleteMany).toHaveBeenCalledWith({
+      where: {
+        token: {
+          in: ['ExponentPushToken[invalidToken]'],
+        },
+      },
+    });
+  });
+
+  it('retries Expo delivery with exponential backoff for transient failures', async () => {
+    const { service, prisma } = createService();
+    prisma.pushToken.findMany.mockResolvedValue([{ token: 'ExponentPushToken[retryToken]' }]);
+    const sendPushNotificationsAsync = (service as any).expo.sendPushNotificationsAsync as jest.Mock;
+    sendPushNotificationsAsync
+      .mockRejectedValueOnce(new Error('transient failure'))
+      .mockResolvedValueOnce([{ status: 'ok', id: 'ticket-1' }]);
+
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation((callback: TimerHandler) => {
+      if (typeof callback === 'function') {
+        callback();
+      }
+      return 0 as unknown as ReturnType<typeof setTimeout>;
+    });
+
+    await service.processQueuedNotification({
+      userIds: ['user-1'],
+      payload: {
+        type: 'settlement_created',
+        title: 'Settlement',
+        body: 'A settlement was recorded',
+      },
+    });
+
+    expect(sendPushNotificationsAsync).toHaveBeenCalledTimes(2);
+    expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 500);
+
+    setTimeoutSpy.mockRestore();
   });
 });

apps/backend/src/notifications/notifications.service.ts

@@ -1,5 +1,5 @@
 import { forwardRef, Inject, Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
-import { Expo, ExpoPushMessage } from 'expo-server-sdk';
+import { Expo, ExpoPushMessage, ExpoPushTicket } from 'expo-server-sdk';
 import Redis from 'ioredis';
 import { AppConfigService } from '../config/app-config.service';
 import { PrismaService } from '../common/prisma.service';
@@ -16,6 +16,8 @@ type NotificationEventPayload = {
 
 @Injectable()
 export class NotificationsService implements OnModuleInit, OnModuleDestroy {
+  private static readonly maxChunkRetries = 3;
+  private static readonly baseRetryDelayMs = 500;
   private readonly logger = new Logger(NotificationsService.name);
   private readonly channel = 'fairshare:notifications';
   private readonly publisher: Redis;
@@ -110,13 +112,14 @@ export class NotificationsService implements OnModuleInit, OnModuleDestroy {
 
     const chunks = this.expo.chunkPushNotifications(messages);
     for (const chunk of chunks) {
-      await this.sendChunkWithRetry(chunk, 1);
+      await this.sendChunkWithRetry(chunk, NotificationsService.maxChunkRetries);
     }
   }
 
   private async sendChunkWithRetry(chunk: ExpoPushMessage[], retries: number): Promise<void> {
     try {
       const tickets = await this.expo.sendPushNotificationsAsync(chunk);
+      await this.removeInvalidTokens(chunk, tickets);
       this.logger.log(
         JSON.stringify({
           event: 'notification_push_sent',
@@ -126,9 +129,48 @@ export class NotificationsService implements OnModuleInit, OnModuleDestroy {
     } catch (error) {
       this.logger.error('Expo push send failed', error instanceof Error ? error.stack : undefined);
       if (retries > 0) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        const attempt = NotificationsService.maxChunkRetries - retries + 1;
+        const delayMs = NotificationsService.baseRetryDelayMs * (2 ** (attempt - 1));
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
         await this.sendChunkWithRetry(chunk, retries - 1);
       }
     }
   }
+
+  private async removeInvalidTokens(chunk: ExpoPushMessage[], tickets: ExpoPushTicket[]): Promise<void> {
+    const invalidTokens = tickets
+      .map((ticket, index) => {
+        if (ticket.status !== 'error') {
+          return null;
+        }
+
+        const errorCode = ticket.details && 'error' in ticket.details ? ticket.details.error : undefined;
+        if (errorCode !== 'DeviceNotRegistered') {
+          return null;
+        }
+
+        const recipient = chunk[index]?.to;
+        return typeof recipient === 'string' ? recipient : null;
+      })
+      .filter((token): token is string => Boolean(token));
+
+    if (invalidTokens.length === 0) {
+      return;
+    }
+
+    await this.prisma.pushToken.deleteMany({
+      where: {
+        token: {
+          in: invalidTokens,
+        },
+      },
+    });
+
+    this.logger.warn(
+      JSON.stringify({
+        event: 'notification_invalid_tokens_removed',
+        count: invalidTokens.length,
+      }),
+    );
+  }
 }