feat: add totalCount to results

Author: ekraffmiller

src/notifications/domain/models/NotificationSubset.ts

@@ -0,0 +1,6 @@
+import { Notification } from './Notification'
+
+export interface NotificationSubset {
+  notifications: Notification[]
+  totalNotificationCount: number
+}

src/notifications/domain/repositories/INotificationsRepository.ts

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

src/notifications/domain/useCases/GetAllNotificationsByUser.ts

@@ -1,8 +1,8 @@
 import { UseCase } from '../../../core/domain/useCases/UseCase'
-import { Notification } from '../models/Notification'
 import { INotificationsRepository } from '../repositories/INotificationsRepository'
+import { NotificationSubset } from '../models/NotificationSubset'
 
-export class GetAllNotificationsByUser implements UseCase<Notification[]> {
+export class GetAllNotificationsByUser implements UseCase<NotificationSubset> {
   constructor(private readonly notificationsRepository: INotificationsRepository) {}
 
   /**
@@ -12,19 +12,19 @@ export class GetAllNotificationsByUser implements UseCase<Notification[]> {
    * @param onlyUnread - Optional parameter to filter only unread notifications
    * @param limit - Optional parameter to limit the number of notifications returned
    * @param offset - Optional parameter to skip a number of notifications (for pagination)
-   * @returns {Promise<Notification[]>} - A promise that resolves to an array of Notification instances.
+   * @returns {Promise<NotificationSubset>} - A promise that resolves to an array of Notification instances.
    */
   async execute(
     inAppNotificationFormat?: boolean,
     onlyUnread?: boolean,
     limit?: number,
     offset?: number
-  ): Promise<Notification[]> {
+  ): Promise<NotificationSubset> {
     return (await this.notificationsRepository.getAllNotificationsByUser(
       inAppNotificationFormat,
       onlyUnread,
       limit,
       offset
-    )) as Notification[]
+    )) as NotificationSubset
   }
 }

src/notifications/infra/repositories/NotificationsRepository.ts

@@ -2,6 +2,7 @@ import { ApiRepository } from '../../../core/infra/repositories/ApiRepository'
 import { INotificationsRepository } from '../../domain/repositories/INotificationsRepository'
 import { Notification } from '../../domain/models/Notification'
 import { NotificationPayload } from '../transformers/NotificationPayload'
+import { NotificationSubset } from '../../domain/models/NotificationSubset'
 
 export class NotificationsRepository extends ApiRepository implements INotificationsRepository {
   private readonly notificationsResourceName: string = 'notifications'
@@ -11,29 +12,33 @@ export class NotificationsRepository extends ApiRepository implements INotificat
     onlyUnread?: boolean,
     limit?: number,
     offset?: number
-  ): Promise<Notification[]> {
-    const queryParams: Record<string, string | number> = {}
-
-    if (inAppNotificationFormat) queryParams.inAppNotificationFormat = 'true'
-    if (onlyUnread) queryParams.onlyUnread = 'true'
-    if (limit !== undefined) queryParams.limit = limit
-    if (offset !== undefined) queryParams.offset = offset
+  ): Promise<NotificationSubset> {
+    const queryParams = new URLSearchParams()
 
+    if (inAppNotificationFormat) queryParams.set('inAppNotificationFormat', 'true')
+    if (onlyUnread) queryParams.set('onlyUnread', 'true')
+    if (limit !== undefined) queryParams.set('limit', limit.toString())
+    if (offset !== undefined) queryParams.set('offset', offset.toString())
+    console.log('Fetching notifications with params:', queryParams.toString())
+    console.log('keys:', Array.from(queryParams.keys()))
+    console.log('length:', Object.keys(queryParams).length)
     return this.doGet(
       this.buildApiEndpoint(this.notificationsResourceName, 'all'),
       true,
-      Object.keys(queryParams).length ? queryParams : undefined
+      queryParams
     )
       .then((response) => {
-        const notifications = response.data.data.notifications
-        return notifications.map((notification: NotificationPayload) => {
+        console.log('Notifications API response:', response.data)
+        const notifications = response.data.data.map((notification: NotificationPayload) => {
           const { dataverseDisplayName, dataverseAlias, ...restNotification } = notification
           return {
             ...restNotification,
             ...(dataverseDisplayName && { collectionDisplayName: dataverseDisplayName }),
             ...(dataverseAlias && { collectionAlias: dataverseAlias })
           }
         }) as Notification[]
+        const totalNotificationCount = response.data.totalCount
+        return { notifications, totalNotificationCount }
       })
       .catch((error) => {
         throw error

test/functional/notifications/DeleteNotification.test.ts

@@ -12,12 +12,14 @@ describe('execute', () => {
   })
 
   test('should successfully delete a notification for authenticated user', async () => {
-    const notifications = await getAllNotificationsByUser.execute()
+    const notificationSubset = await getAllNotificationsByUser.execute()
+    const notifications = notificationSubset.notifications
     const notificationId = notifications[notifications.length - 1].id
 
     await deleteNotification.execute(notificationId)
 
-    const notificationsAfterDelete = await getAllNotificationsByUser.execute()
+    const notificationsAfterDeleteSubset = await getAllNotificationsByUser.execute()
+    const notificationsAfterDelete = notificationsAfterDeleteSubset.notifications
     expect(notificationsAfterDelete.length).toBe(notifications.length - 1)
   })
 

test/functional/notifications/GetAllNotificationsByUser.test.ts

@@ -1,7 +1,7 @@
-import { ApiConfig, getAllNotificationsByUser, Notification } from '../../../src'
+import { ApiConfig, getAllNotificationsByUser } from '../../../src'
 import { TestConstants } from '../../testHelpers/TestConstants'
 import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
-
+import { NotificationSubset } from '../../../src/notifications/domain/models/NotificationSubset'
 describe('execute', () => {
   beforeEach(async () => {
     ApiConfig.init(
@@ -12,30 +12,35 @@ describe('execute', () => {
   })
 
   test('should successfully return notifications for authenticated user', async () => {
-    const notifications: Notification[] = await getAllNotificationsByUser.execute()
+    const result: NotificationSubset = await getAllNotificationsByUser.execute()
+    const notifications = result.notifications
 
     expect(notifications).not.toBeNull()
     expect(Array.isArray(notifications)).toBe(true)
   })
 
   test('should have correct notification properties if notifications exist', async () => {
-    const notifications = await getAllNotificationsByUser.execute()
+    const result: NotificationSubset = await getAllNotificationsByUser.execute()
+    const notifications = result.notifications
 
     expect(notifications[0]).toHaveProperty('id')
     expect(notifications[0]).toHaveProperty('type')
     expect(notifications[0]).toHaveProperty('sentTimestamp')
   })
 
   test('should have correct in-app notification properties when inAppNotificationFormat is true', async () => {
-    const notifications = await getAllNotificationsByUser.execute(true)
+    const result: NotificationSubset = await getAllNotificationsByUser.execute(true)
+    const notifications = result.notifications
 
     expect(notifications[0]).toHaveProperty('id')
     expect(notifications[0]).toHaveProperty('type')
     expect(notifications[0]).toHaveProperty('sentTimestamp')
     expect(notifications[0]).toHaveProperty('displayAsRead')
   })
+
   test('should have correct in-app notification properties when filter and paging params are set', async () => {
-    const notifications = await getAllNotificationsByUser.execute(true, true, 1, 0)
+    const result: NotificationSubset = await getAllNotificationsByUser.execute(true, true, 1, 0)
+    const notifications = result.notifications
 
     expect(notifications[0]).toHaveProperty('id')
     expect(notifications[0]).toHaveProperty('type')

test/integration/notifications/NotificationsRepository.test.ts

@@ -16,6 +16,7 @@ import {
   createCollectionDTO,
   deleteCollectionViaApi
 } from '../../testHelpers/collections/collectionHelper'
+import { NotificationSubset } from '../../../src/notifications/domain/models/NotificationSubset'
 
 describe('NotificationsRepository', () => {
   const sut: NotificationsRepository = new NotificationsRepository()
@@ -36,12 +37,12 @@ describe('NotificationsRepository', () => {
     await publishDatasetViaApi(testDatasetIds.numericId)
     await waitForNoLocks(testDatasetIds.numericId, 10)
 
-    const notifications: Notification[] = await sut.getAllNotificationsByUser()
+    const notificationSubset: NotificationSubset = await sut.getAllNotificationsByUser()
 
-    expect(Array.isArray(notifications)).toBe(true)
-    expect(notifications.length).toBeGreaterThan(0)
+    expect(Array.isArray(notificationSubset.notifications)).toBe(true)
+    expect(notificationSubset.notifications.length).toBeGreaterThan(0)
 
-    const publishedNotification = notifications.find(
+    const publishedNotification = notificationSubset.notifications.find(
       (n) => n.type === NotificationType.PUBLISHEDDS
     ) as Notification
 
@@ -62,14 +63,14 @@ describe('NotificationsRepository', () => {
   })
 
   test('should delete a notification by ID', async () => {
-    const notifications: Notification[] = await sut.getAllNotificationsByUser()
+    const notificationSubset: NotificationSubset = await sut.getAllNotificationsByUser()
 
-    const notificationToDelete = notifications[0]
+    const notificationToDelete = notificationSubset.notifications[0]
 
     await sut.deleteNotification(notificationToDelete.id)
 
-    const notificationsAfterDelete: Notification[] = await sut.getAllNotificationsByUser()
-    const deletedNotification = notificationsAfterDelete.find(
+    const notificationsAfterDelete: NotificationSubset = await sut.getAllNotificationsByUser()
+    const deletedNotification = notificationsAfterDelete.notifications.find(
       (n) => n.id === notificationToDelete.id
     )
     expect(deletedNotification).toBeUndefined()
@@ -86,27 +87,26 @@ describe('NotificationsRepository', () => {
   })
 
   test('should return notifications with basic properties when inAppNotificationFormat is true', async () => {
-    const notifications: Notification[] = await sut.getAllNotificationsByUser(true)
+    const notificationSubset: NotificationSubset = await sut.getAllNotificationsByUser(true)
 
-    const notification = notifications[0]
+    const notification = notificationSubset.notifications[0]
     expect(notification).toHaveProperty('id')
     expect(notification).toHaveProperty('type')
     expect(notification).toHaveProperty('sentTimestamp')
     expect(notification).toHaveProperty('displayAsRead')
   })
 
   test('should find notification with ASSIGNROLE type that has not been deleted', async () => {
-    const notifications: Notification[] = await sut.getAllNotificationsByUser(true)
+    const notificationSubset: NotificationSubset = await sut.getAllNotificationsByUser(true)
 
-    const assignRoleNotification = notifications.find(
+    const assignRoleNotification = notificationSubset.notifications.find(
       (n) => n.type === NotificationType.ASSIGNROLE && !n.objectDeleted
     )
 
     expect(assignRoleNotification).toBeDefined()
     expect(assignRoleNotification?.type).toBe(NotificationType.ASSIGNROLE)
     expect(assignRoleNotification?.sentTimestamp).toBeDefined()
     expect(assignRoleNotification?.displayAsRead).toBeDefined()
-    expect(assignRoleNotification?.collectionDisplayName).toBeDefined()
 
     expect(assignRoleNotification?.roleAssignments).toBeDefined()
     expect(assignRoleNotification?.roleAssignments?.length).toBeGreaterThan(0)
@@ -125,11 +125,11 @@ describe('NotificationsRepository', () => {
     expect(createdCollectionId).toBeDefined()
     expect(createdCollectionId).toBeGreaterThan(0)
 
-    const notifications: Notification[] = await sut.getAllNotificationsByUser(true)
-    expect(Array.isArray(notifications)).toBe(true)
-    expect(notifications.length).toBeGreaterThan(0)
+    const notificationSubset: NotificationSubset = await sut.getAllNotificationsByUser(true, true)
+    expect(Array.isArray(notificationSubset.notifications)).toBe(true)
+    expect(notificationSubset.notifications.length).toBeGreaterThan(0)
 
-    const createdvNotification = notifications.find(
+    const createdvNotification = notificationSubset.notifications.find(
       (n) => n.collectionAlias === testCollectionAlias
     )
 
@@ -145,9 +145,9 @@ describe('NotificationsRepository', () => {
   })
 
   test('should return array when inAppNotificationFormat is false', async () => {
-    const notifications: Notification[] = await sut.getAllNotificationsByUser(false)
+    const notificationSubset: NotificationSubset = await sut.getAllNotificationsByUser(false)
 
-    expect(Array.isArray(notifications)).toBe(true)
+    expect(Array.isArray(notificationSubset.notifications)).toBe(true)
   })
 
   test('should return unread count', async () => {
@@ -158,16 +158,18 @@ describe('NotificationsRepository', () => {
   })
 
   test('should mark notification as read successfully', async () => {
-    const notifications: Notification[] = await sut.getAllNotificationsByUser()
+    const notificationSubset: NotificationSubset = await sut.getAllNotificationsByUser()
 
-    expect(notifications.length).toBeGreaterThan(0)
+    expect(notificationSubset.notifications.length).toBeGreaterThan(0)
 
-    const unreadNotification = notifications[0]
+    const unreadNotification = notificationSubset.notifications[0]
 
     await expect(sut.markNotificationAsRead(unreadNotification.id)).resolves.toBeUndefined()
 
-    const updatedNotifications: Notification[] = await sut.getAllNotificationsByUser()
-    const updatedNotification = updatedNotifications.find((n) => n.id === unreadNotification.id)
+    const updatedNotificationSubset: NotificationSubset = await sut.getAllNotificationsByUser()
+    const updatedNotification = updatedNotificationSubset.notifications.find(
+      (n) => n.id === unreadNotification.id
+    )
 
     expect(updatedNotification?.displayAsRead).toBe(true)
   })
@@ -184,25 +186,40 @@ describe('NotificationsRepository', () => {
     )
   })
   test('should only return unread notifications when onlyUnread is true', async () => {
-    const notifications: Notification[] = await sut.getAllNotificationsByUser(true, true)
+    const notificationSubset: NotificationSubset = await sut.getAllNotificationsByUser(true, true)
 
-    expect(Array.isArray(notifications)).toBe(true)
-    const originalUnreadCount = notifications.length
-    expect(notifications.length).toBeGreaterThanOrEqual(0)
+    expect(Array.isArray(notificationSubset.notifications)).toBe(true)
+    const originalUnreadCount = notificationSubset.totalNotificationCount
+    expect(notificationSubset.notifications.length).toBeGreaterThanOrEqual(0)
 
-    await expect(sut.markNotificationAsRead(notifications[0].id)).resolves.toBeUndefined()
+    await expect(
+      sut.markNotificationAsRead(notificationSubset.notifications[0].id)
+    ).resolves.toBeUndefined()
 
-    const updatedNotifications: Notification[] = await sut.getAllNotificationsByUser(true, true)
-    expect(updatedNotifications.length).toBe(originalUnreadCount - 1)
+    const updatedNotifications: NotificationSubset = await sut.getAllNotificationsByUser(
+      true,
+      true,
+      10,
+      0
+    )
+    expect(updatedNotifications.totalNotificationCount).toBe(originalUnreadCount - 1)
 
-    const hasReadNotifications = notifications.some((n) => n.displayAsRead === true)
+    const hasReadNotifications = notificationSubset.notifications.some(
+      (n) => n.displayAsRead === true
+    )
     expect(hasReadNotifications).toBe(false)
   })
   test('should return limited number of notifications when limit is set', async () => {
     const limit = 1
-    const notifications: Notification[] = await sut.getAllNotificationsByUser(true, false, limit, 0)
+    const notificationSubset: NotificationSubset = await sut.getAllNotificationsByUser(
+      true,
+      false,
+      limit,
+      0
+    )
 
-    expect(Array.isArray(notifications)).toBe(true)
-    expect(notifications.length).toBeLessThanOrEqual(limit)
+    expect(Array.isArray(notificationSubset.notifications)).toBe(true)
+    expect(notificationSubset.notifications.length).toBeLessThanOrEqual(limit)
+    expect(notificationSubset.totalNotificationCount).toBeGreaterThanOrEqual(limit)
   })
 })