@umituz/react-native-notifications 1.0.5 → 1.1.0

package/src/__tests__/useNotificationActions.test.ts

@@ -0,0 +1,189 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { useNotificationActions } from '../src/infrastructure/hooks/actions/useNotificationActions';
+import { useNotificationsState } from '../src/infrastructure/hooks/state/useNotificationsState';
+
+// Mock AsyncStorage
+jest.mock('@react-native-async-storage/async-storage', () => ({
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+}));
+
+// Mock expo-notifications
+jest.mock('expo-notifications', () => ({
+  scheduleNotificationAsync: jest.fn(),
+}));
+
+// Mock services
+jest.mock('../src/infrastructure/services/delivery/NotificationDelivery', () => ({
+  NotificationDelivery: jest.fn().mockImplementation(() => ({
+    deliver: jest.fn().mockResolvedValue(undefined),
+  })),
+}));
+
+jest.mock('../src/infrastructure/services/channels/ChannelManager', () => ({
+  ChannelManager: jest.fn().mockImplementation(() => ({
+    register: jest.fn(),
+    verify: jest.fn(),
+  })),
+}));
+
+jest.mock('../src/infrastructure/services/preferences/PreferencesManager', () => ({
+  PreferencesManager: jest.fn().mockImplementation(() => ({
+    update: jest.fn().mockResolvedValue(true),
+  })),
+}));
+
+describe('useNotificationActions', () => {
+  let mockState: any;
+  let mockSetters: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockState = {
+      notifications: [],
+      channels: [],
+      unreadCount: 0,
+      preferences: null,
+      loading: false,
+      error: null,
+      hasMore: true,
+    };
+
+    mockSetters = {
+      setNotifications: jest.fn(),
+      setChannels: jest.fn(),
+      setUnreadCount: jest.fn(),
+      setPreferences: jest.fn(),
+      setLoading: jest.fn(),
+      setError: jest.fn(),
+      setHasMore: jest.fn(),
+    };
+
+    (AsyncStorage.getItem as jest.Mock).mockResolvedValue('[]');
+    (AsyncStorage.setItem as jest.Mock).mockResolvedValue(undefined);
+  });
+
+  describe('sendNotification', () => {
+    it('should send a notification successfully', async () => {
+      const { result } = renderHook(() => useNotificationActions(mockState, mockSetters));
+
+      const options = {
+        title: 'Test Notification',
+        body: 'Test body',
+        data: { key: 'value' },
+      };
+
+      let resultNotifications: any[] = [];
+      await act(async () => {
+        resultNotifications = await result.current.sendNotification(options);
+      });
+
+      expect(resultNotifications).toHaveLength(1);
+      expect(resultNotifications[0]).toMatchObject({
+        title: 'Test Notification',
+        body: 'Test body',
+        data: { key: 'value' },
+        read: false,
+      });
+      expect(AsyncStorage.setItem).toHaveBeenCalled();
+      expect(mockSetters.setError).toHaveBeenCalledWith(null);
+    });
+
+    it('should handle send notification errors', async () => {
+      (AsyncStorage.setItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+      const { result } = renderHook(() => useNotificationActions(mockState, mockSetters));
+
+      const options = {
+        title: 'Test',
+        body: 'Test',
+      };
+
+      let resultNotifications: any[] = [];
+      await act(async () => {
+        resultNotifications = await result.current.sendNotification(options);
+      });
+
+      expect(resultNotifications).toHaveLength(0);
+      expect(mockSetters.setError).toHaveBeenCalledWith('Storage error');
+    });
+
+    it('should schedule notification with date', async () => {
+      const { result } = renderHook(() => useNotificationActions(mockState, mockSetters));
+
+      const scheduledDate = new Date('2025-01-15T09:00:00');
+      const options = {
+        title: 'Scheduled Notification',
+        body: 'Test body',
+        scheduled_for: scheduledDate,
+      };
+
+      await act(async () => {
+        await result.current.sendNotification(options);
+      });
+
+      const notificationData = JSON.parse((AsyncStorage.setItem as jest.Mock).mock.calls[0][1]);
+      expect(notificationData[0]).toMatchObject({
+        scheduled_for: scheduledDate.toISOString(),
+      });
+    });
+  });
+
+  describe('markAsRead', () => {
+    it('should mark notification as read successfully', async () => {
+      const mockNotifications = [
+        { id: 'notif-1', title: 'Test 1', read: false },
+        { id: 'notif-2', title: 'Test 2', read: false },
+      ];
+      (AsyncStorage.getItem as jest.Mock).mockResolvedValue(JSON.stringify(mockNotifications));
+
+      const { result } = renderHook(() => useNotificationActions(mockState, mockSetters));
+
+      let success = false;
+      await act(async () => {
+        success = await result.current.markAsRead('notif-1');
+      });
+
+      expect(success).toBe(true);
+      expect(AsyncStorage.setItem).toHaveBeenCalled();
+      expect(mockSetters.setUnreadCount).toHaveBeenCalledWith(0);
+    });
+
+    it('should handle mark as read errors', async () => {
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(new Error('Read error'));
+      const { result } = renderHook(() => useNotificationActions(mockState, mockSetters));
+
+      let success = false;
+      await act(async () => {
+        success = await result.current.markAsRead('notif-1');
+      });
+
+      expect(success).toBe(false);
+      expect(mockSetters.setError).toHaveBeenCalledWith('Read error');
+    });
+  });
+
+  describe('markAllAsRead', () => {
+    it('should mark all notifications as read', async () => {
+      const mockNotifications = [
+        { id: 'notif-1', title: 'Test 1', read: false },
+        { id: 'notif-2', title: 'Test 2', read: false },
+      ];
+      (AsyncStorage.getItem as jest.Mock).mockResolvedValue(JSON.stringify(mockNotifications));
+
+      const { result } = renderHook(() => useNotificationActions(mockState, mockSetters));
+
+      let success = false;
+      await act(async () => {
+        success = await result.current.markAllAsRead();
+      });
+
+      expect(success).toBe(true);
+      expect(mockSetters.setUnreadCount).toHaveBeenCalledWith(0);
+      
+      const savedData = JSON.parse((AsyncStorage.setItem as jest.Mock).mock.calls[0][1]);
+      expect(savedData.every((n: any) => n.read)).toBe(true);
+    });
+  });
+});

package/src/__tests__/useNotificationRefresh.test.ts

@@ -0,0 +1,213 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { useNotificationRefresh } from '../src/infrastructure/hooks/utils/useNotificationRefresh';
+
+// Mock AsyncStorage
+jest.mock('@react-native-async-storage/async-storage', () => ({
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+}));
+
+// Mock services
+jest.mock('../src/infrastructure/services/channels/ChannelManager', () => ({
+  ChannelManager: jest.fn().mockImplementation(() => ({
+    getActiveChannels: jest.fn().mockResolvedValue([]),
+  })),
+}));
+
+jest.mock('../src/infrastructure/services/preferences/PreferencesManager', () => ({
+  PreferencesManager: jest.fn().mockImplementation(() => ({
+    get: jest.fn().mockResolvedValue(null),
+  })),
+}));
+
+describe('useNotificationRefresh', () => {
+  let mockSetters: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockSetters = {
+      setNotifications: jest.fn(),
+      setChannels: jest.fn(),
+      setUnreadCount: jest.fn(),
+      setPreferences: jest.fn(),
+      setLoading: jest.fn(),
+      setError: jest.fn(),
+      setHasMore: jest.fn(),
+    };
+
+    (AsyncStorage.getItem as jest.Mock).mockResolvedValue('[]');
+  });
+
+  describe('refreshNotifications', () => {
+    it('should refresh notifications successfully', async () => {
+      const mockNotifications = [
+        { id: 'notif-1', title: 'Test 1', read: false },
+        { id: 'notif-2', title: 'Test 2', read: true },
+        { id: 'notif-3', title: 'Test 3', read: false },
+      ];
+      (AsyncStorage.getItem as jest.Mock).mockResolvedValue(JSON.stringify(mockNotifications));
+
+      const { result } = renderHook(() => useNotificationRefresh(2, mockSetters));
+
+      await act(async () => {
+        await result.current.refreshNotifications();
+      });
+
+      expect(mockSetters.setLoading).toHaveBeenCalledWith(true);
+      expect(mockSetters.setError).toHaveBeenCalledWith(null);
+      expect(mockSetters.setNotifications).toHaveBeenCalledWith(mockNotifications.slice(0, 2));
+      expect(mockSetters.setUnreadCount).toHaveBeenCalledWith(2);
+      expect(mockSetters.setHasMore).toHaveBeenCalledWith(true);
+      expect(mockSetters.setLoading).toHaveBeenCalledWith(false);
+    });
+
+    it('should handle empty notifications list', async () => {
+      (AsyncStorage.getItem as jest.Mock).mockResolvedValue('[]');
+
+      const { result } = renderHook(() => useNotificationRefresh(10, mockSetters));
+
+      await act(async () => {
+        await result.current.refreshNotifications();
+      });
+
+      expect(mockSetters.setNotifications).toHaveBeenCalledWith([]);
+      expect(mockSetters.setUnreadCount).toHaveBeenCalledWith(0);
+      expect(mockSetters.setHasMore).toHaveBeenCalledWith(false);
+    });
+
+    it('should handle refresh errors', async () => {
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(new Error('Refresh error'));
+
+      const { result } = renderHook(() => useNotificationRefresh(10, mockSetters));
+
+      await act(async () => {
+        await result.current.refreshNotifications();
+      });
+
+      expect(mockSetters.setError).toHaveBeenCalledWith('Refresh error');
+      expect(mockSetters.setLoading).toHaveBeenCalledWith(false);
+    });
+  });
+
+  describe('loadMoreNotifications', () => {
+    it('should load more notifications', async () => {
+      const mockNotifications = Array.from({ length: 15 }, (_, i) => ({
+        id: `notif-${i}`,
+        title: `Test ${i}`,
+        read: false,
+      }));
+      (AsyncStorage.getItem as jest.Mock).mockResolvedValue(JSON.stringify(mockNotifications));
+
+      const { result } = renderHook(() => useNotificationRefresh(5, mockSetters));
+
+      // First load
+      await act(async () => {
+        await result.current.refreshNotifications();
+      });
+
+      // Load more
+      await act(async () => {
+        await result.current.loadMoreNotifications(5, true, false);
+      });
+
+      expect(mockSetters.setNotifications).toHaveBeenCalledTimes(2);
+      expect(mockSetters.setHasMore).toHaveBeenCalledWith(true);
+    });
+
+    it('should not load more if no more notifications', async () => {
+      const { result } = renderHook(() => useNotificationRefresh(10, mockSetters));
+
+      await act(async () => {
+        await result.current.loadMoreNotifications(5, false, false);
+      });
+
+      expect(mockSetters.setNotifications).not.toHaveBeenCalled();
+    });
+
+    it('should not load more if already loading', async () => {
+      const { result } = renderHook(() => useNotificationRefresh(10, mockSetters));
+
+      await act(async () => {
+        await result.current.loadMoreNotifications(5, true, true);
+      });
+
+      expect(mockSetters.setNotifications).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('refreshChannels', () => {
+    it('should refresh channels successfully', async () => {
+      const mockChannels = [
+        { id: 'channel-1', name: 'Channel 1' },
+        { id: 'channel-2', name: 'Channel 2' },
+      ];
+
+      const { result } = renderHook(() => useNotificationRefresh(10, mockSetters));
+
+      await act(async () => {
+        await result.current.refreshChannels();
+      });
+
+      expect(mockSetters.setChannels).toHaveBeenCalledWith(mockChannels);
+    });
+
+    it('should handle channel refresh errors silently', async () => {
+      const ChannelManager = require('../src/infrastructure/services/channels/ChannelManager').ChannelManager;
+      ChannelManager.mockImplementation(() => ({
+        getActiveChannels: jest.fn().mockRejectedValue(new Error('Channel error')),
+      }));
+
+      const { result } = renderHook(() => useNotificationRefresh(10, mockSetters));
+
+      await act(async () => {
+        await result.current.refreshChannels();
+      });
+
+      expect(mockSetters.setChannels).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('refreshPreferences', () => {
+    it('should refresh preferences successfully', async () => {
+      const mockPreferences = { enabled: true, sound: false };
+
+      const { result } = renderHook(() => useNotificationRefresh(10, mockSetters));
+
+      await act(async () => {
+        await result.current.refreshPreferences();
+      });
+
+      expect(mockSetters.setPreferences).toHaveBeenCalledWith(mockPreferences);
+    });
+
+    it('should handle preferences refresh errors silently', async () => {
+      const PreferencesManager = require('../src/infrastructure/services/preferences/PreferencesManager').PreferencesManager;
+      PreferencesManager.mockImplementation(() => ({
+        get: jest.fn().mockRejectedValue(new Error('Preferences error')),
+      }));
+
+      const { result } = renderHook(() => useNotificationRefresh(10, mockSetters));
+
+      await act(async () => {
+        await result.current.refreshPreferences();
+      });
+
+      expect(mockSetters.setPreferences).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('cleanup', () => {
+    it('should cleanup properly', async () => {
+      const { result } = renderHook(() => useNotificationRefresh(10, mockSetters));
+
+      await act(async () => {
+        result.current.cleanup();
+      });
+
+      // Should not throw any errors
+      expect(true).toBe(true);
+    });
+  });
+});

package/src/index.ts

@@ -32,3 +32,10 @@ export { NotificationManager } from './infrastructure/services/NotificationManag
 
 // Hooks
 export { useNotificationSettings } from './infrastructure/hooks/useNotificationSettings';
+
+// ============================================================================
+// PRESENTATION LAYER EXPORTS
+// ============================================================================
+
+// Screens
+export { NotificationsScreen } from './presentation/screens/NotificationsScreen';

package/src/infrastructure/hooks/actions/useNotificationActions.ts

@@ -10,13 +10,8 @@ import type {
 import { NotificationDelivery } from '../../services/delivery/NotificationDelivery';
 import { ChannelManager } from '../../services/channels/ChannelManager';
 import { PreferencesManager } from '../../services/preferences/PreferencesManager';
+import { devLog } from '../../utils/dev';
 
-/**
- * useNotificationActions - Offline Notification Actions
- *
- * All actions use AsyncStorage and expo-notifications.
- * NO backend - pure offline.
- */
 export const useNotificationActions = (state: any, setters: any) => {
   const {
     setNotifications,
@@ -35,7 +30,6 @@ export const useNotificationActions = (state: any, setters: any) => {
       try {
         setError(null);
 
-        // Create notification
         const notification: Notification = {
           id: `notif_${Date.now()}`,
           title: options.title,
@@ -46,7 +40,6 @@ export const useNotificationActions = (state: any, setters: any) => {
           read: false,
         };
 
-        // Save to AsyncStorage
         const data = await AsyncStorage.getItem('@notifications:list');
         const notifications: Notification[] = data ? JSON.parse(data) : [];
         notifications.unshift(notification);
@@ -55,9 +48,10 @@ export const useNotificationActions = (state: any, setters: any) => {
           JSON.stringify(notifications)
         );
 
-        // Deliver using expo-notifications
         await notificationDelivery.deliver(notification);
 
+        devLog('[useNotificationActions] Notification sent:', notification.id);
+
         return [notification];
       } catch (err) {
         setError(
@@ -91,6 +85,8 @@ export const useNotificationActions = (state: any, setters: any) => {
         );
         setUnreadCount((prev: number) => Math.max(0, prev - 1));
 
+        devLog('[useNotificationActions] Marked as read:', notificationId);
+
         return true;
       } catch (err) {
         setError(
@@ -116,6 +112,8 @@ export const useNotificationActions = (state: any, setters: any) => {
       );
       setUnreadCount(0);
 
+      devLog('[useNotificationActions] All notifications marked as read');
+
       return true;
     } catch (err) {
       setError(
@@ -125,109 +123,9 @@ export const useNotificationActions = (state: any, setters: any) => {
     }
   }, [setNotifications, setUnreadCount, setError]);
 
-  const deleteNotification = useCallback(
-    async (notificationId: string): Promise<boolean> => {
-      try {
-        const data = await AsyncStorage.getItem('@notifications:list');
-        const notifications: Notification[] = data ? JSON.parse(data) : [];
-
-        const deleted = notifications.find((n) => n.id === notificationId);
-        const filtered = notifications.filter((n) => n.id !== notificationId);
-
-        await AsyncStorage.setItem(
-          '@notifications:list',
-          JSON.stringify(filtered)
-        );
-
-        setNotifications((prev: Notification[]) =>
-          prev.filter((n) => n.id !== notificationId)
-        );
-
-        if (deleted && !deleted.read) {
-          setUnreadCount((prev: number) => Math.max(0, prev - 1));
-        }
-
-        return true;
-      } catch (err) {
-        setError(
-          err instanceof Error ? err.message : 'Failed to delete notification'
-        );
-        return false;
-      }
-    },
-    [setNotifications, setUnreadCount, setError]
-  );
-
-  const registerChannel = useCallback(
-    async (
-      channelType: 'push' | 'in_app',
-      preferences: Record<string, any> = {}
-    ): Promise<NotificationChannel | null> => {
-      try {
-        const channel = await channelManager.register(channelType, preferences);
-        if (channel) {
-          setChannels((prev: NotificationChannel[]) => [...prev, channel]);
-        }
-        return channel;
-      } catch (err) {
-        setError(
-          err instanceof Error ? err.message : 'Failed to register channel'
-        );
-        return null;
-      }
-    },
-    [setChannels, setError]
-  );
-
-  const verifyChannel = useCallback(
-    async (channelId: string): Promise<boolean> => {
-      try {
-        const success = await channelManager.verify(channelId);
-        if (success) {
-          setChannels((prev: NotificationChannel[]) =>
-            prev.map((c) =>
-              c.id === channelId ? { ...c, is_verified: true } : c
-            )
-          );
-        }
-        return success;
-      } catch (err) {
-        setError(
-          err instanceof Error ? err.message : 'Failed to verify channel'
-        );
-        return false;
-      }
-    },
-    [setChannels, setError]
-  );
-
-  const updatePreferences = useCallback(
-    async (newPreferences: Partial<NotificationPreferences>): Promise<boolean> => {
-      try {
-        const success = await preferencesManager.update(newPreferences);
-        if (success) {
-          setPreferences((prev: NotificationPreferences | null) =>
-            prev ? { ...prev, ...newPreferences } : null
-          );
-        }
-        return success;
-      } catch (err) {
-        setError(
-          err instanceof Error ? err.message : 'Failed to update preferences'
-        );
-        return false;
-      }
-    },
-    [setPreferences, setError]
-  );
-
   return {
     sendNotification,
     markAsRead,
     markAllAsRead,
-    deleteNotification,
-    registerChannel,
-    verifyChannel,
-    updatePreferences,
   };
-};
+};