feat: add pagination

Author: ChengShi-1

src/notifications/domain/repositories/INotificationsRepository.ts

@@ -1,7 +1,12 @@
 import { Notification } from '../models/Notification'
 
 export interface INotificationsRepository {
-  getAllNotificationsByUser(inAppNotificationFormat?: boolean): Promise<Notification[]>
+  getAllNotificationsByUser(
+    inAppNotificationFormat?: boolean,
+    onlyUnread?: boolean,
+    limit?: number,
+    offset?: number
+  ): Promise<Notification[]>
   deleteNotification(notificationId: number): Promise<void>
   getUnreadNotificationsCount(): Promise<number>
   markNotificationAsRead(notificationId: number): Promise<void>

src/notifications/domain/useCases/GetAllNotificationsByUser.ts

@@ -11,9 +11,17 @@ export class GetAllNotificationsByUser implements UseCase<Notification[]> {
    * @param inAppNotificationFormat - Optional parameter to retrieve fields needed for in-app notifications
    * @returns {Promise<Notification[]>} - A promise that resolves to an array of Notification instances.
    */
-  async execute(inAppNotificationFormat?: boolean): Promise<Notification[]> {
+  async execute(
+    inAppNotificationFormat?: boolean,
+    onlyUnread?: boolean,
+    limit?: number,
+    offset?: number
+  ): Promise<Notification[]> {
     return (await this.notificationsRepository.getAllNotificationsByUser(
-      inAppNotificationFormat
+      inAppNotificationFormat,
+      onlyUnread,
+      limit,
+      offset
     )) as Notification[]
   }
 }

src/notifications/infra/repositories/NotificationsRepository.ts

@@ -7,13 +7,28 @@ export class NotificationsRepository extends ApiRepository implements INotificat
   private readonly notificationsResourceName: string = 'notifications'
 
   public async getAllNotificationsByUser(
-    inAppNotificationFormat?: boolean
+    inAppNotificationFormat?: boolean,
+    onlyUnread?: boolean,
+    limit?: number,
+    offset?: number
   ): Promise<Notification[]> {
-    const queryParams = inAppNotificationFormat ? { inAppNotificationFormat: 'true' } : undefined
+    const queryParams = new URLSearchParams()
+    if (inAppNotificationFormat) {
+      queryParams.set('inAppNotificationFormat', 'true')
+    }
+    if (onlyUnread) {
+      queryParams.set('onlyUnread', 'true')
+    }
+    if (typeof limit === 'number') {
+      queryParams.set('limit', limit.toString())
+    }
+    if (typeof offset === 'number') {
+      queryParams.set('offset', offset.toString())
+    }
     return this.doGet(
       this.buildApiEndpoint(this.notificationsResourceName, 'all'),
       true,
-      queryParams
+      queryParams.toString().length > 0 ? queryParams : undefined
     )
       .then((response) => {
         const notifications = response.data.data.notifications

test/integration/notifications/NotificationsRepository.test.ts

@@ -9,7 +9,11 @@ import {
   NotificationType
 } from '../../../src/notifications/domain/models/Notification'
 import { createDataset, CreatedDatasetIdentifiers } from '../../../src/datasets'
-import { publishDatasetViaApi, waitForNoLocks } from '../../testHelpers/datasets/datasetHelper'
+import {
+  publishDatasetViaApi,
+  waitForNoLocks,
+  deletePublishedDatasetViaApi
+} from '../../testHelpers/datasets/datasetHelper'
 import { WriteError } from '../../../src'
 import { createCollection } from '../../../src/collections'
 import {
@@ -95,7 +99,24 @@ describe('NotificationsRepository', () => {
     expect(notification).toHaveProperty('displayAsRead')
   })
 
-  test('should find notification with ASSIGNROLE type that has not been deleted', async () => {
+  test('should return only unread notifications when onlyUnread is true (if any exist)', async () => {
+    const notifications: Notification[] = await sut.getAllNotificationsByUser(true, true)
+
+    expect(Array.isArray(notifications)).toBe(true)
+    expect(Array.isArray(notifications)).toBe(true)
+    expect(notifications.every((n) => n.displayAsRead === false)).toBe(true)
+  })
+
+  test('should paginate results using limit and offset', async () => {
+    const limit = 1
+    const page1: Notification[] = await sut.getAllNotificationsByUser(true, undefined, limit, 0)
+    const page2: Notification[] = await sut.getAllNotificationsByUser(true, undefined, limit, 1)
+
+    expect(page1.length).toBeLessThanOrEqual(limit)
+    expect(page2.length).toBeLessThanOrEqual(limit)
+
+    // Always run the assertion, but only if both pages have one notification each
+    expect(page1.length !== 1 || page2.length !== 1 || page1[0].id !== page2[0].id).toBe(true)
     const notifications: Notification[] = await sut.getAllNotificationsByUser(true)
 
     const assignRoleNotification = notifications.find(
@@ -116,6 +137,46 @@ describe('NotificationsRepository', () => {
     expect(assignRoleNotification?.roleAssignments?.[0]).toHaveProperty('definitionPointId')
   })
 
+  test('should generate 5+ notifications and verify pagination across pages', async () => {
+    const createdDatasets: CreatedDatasetIdentifiers[] = []
+    try {
+      const howMany = 5
+      for (let i = 0; i < howMany; i++) {
+        const ids = await createDataset.execute(TestConstants.TEST_NEW_DATASET_DTO)
+        createdDatasets.push(ids)
+        await publishDatasetViaApi(ids.numericId)
+        await waitForNoLocks(ids.numericId, 10)
+      }
+
+      const limit = 5
+      const page1: Notification[] = await sut.getAllNotificationsByUser(true, undefined, limit, 0)
+      const page2: Notification[] = await sut.getAllNotificationsByUser(true, undefined, limit, 5)
+      const page3: Notification[] = await sut.getAllNotificationsByUser(true, undefined, limit, 10)
+      expect(page1.length).toBeLessThanOrEqual(limit)
+      expect(page2.length).toBeLessThanOrEqual(limit)
+      expect(page3.length).toBeLessThanOrEqual(limit)
+
+      const ids1 = new Set(page1.map((n) => n.id))
+      const ids2 = new Set(page2.map((n) => n.id))
+      const ids3 = new Set(page3.map((n) => n.id))
+
+      const intersects = (a: Set<number>, b: Set<number>): boolean => {
+        for (const x of a) {
+          if (b.has(x)) return true
+        }
+        return false
+      }
+
+      expect(page1.length === 0 || page2.length === 0 || !intersects(ids1, ids2)).toBe(true)
+      expect(page1.length === 0 || page3.length === 0 || !intersects(ids1, ids3)).toBe(true)
+      expect(page2.length === 0 || page3.length === 0 || !intersects(ids2, ids3)).toBe(true)
+    } finally {
+      for (const d of createdDatasets) {
+        await deletePublishedDatasetViaApi(d.persistentId)
+      }
+    }
+  })
+
   test('should create a collection and find the notification with CREATEDV type', async () => {
     const testCollectionAlias = 'test-notification-collection'
     const createdCollectionId = await createCollection.execute(