@umituz/react-native-notifications 1.0.5 → 1.1.0

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

@@ -0,0 +1,131 @@
+import { useCallback } from 'react';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type {
+  Notification,
+  NotificationChannel,
+  NotificationPreferences,
+} from '../types';
+import { ChannelManager } from '../../services/channels/ChannelManager';
+import { PreferencesManager } from '../../services/preferences/PreferencesManager';
+import { devLog } from '../../utils/dev';
+
+export const useNotificationManagementActions = (state: any, setters: any) => {
+  const { setNotifications, setUnreadCount, setChannels, setPreferences, setError } = setters;
+
+  const channelManager = new ChannelManager();
+  const preferencesManager = new PreferencesManager();
+
+  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));
+        }
+
+        devLog('[useNotificationManagementActions] Deleted notification:', notificationId);
+
+        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]);
+        }
+
+        devLog('[useNotificationManagementActions] Channel registered:', channel?.id);
+
+        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
+            )
+          );
+        }
+
+        devLog('[useNotificationManagementActions] Channel verified:', channelId, success);
+
+        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
+          );
+        }
+
+        devLog('[useNotificationManagementActions] Preferences updated:', newPreferences);
+
+        return success;
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : 'Failed to update preferences'
+        );
+        return false;
+      }
+    },
+    [setPreferences, setError]
+  );
+
+  return {
+    deleteNotification,
+    registerChannel,
+    verifyChannel,
+    updatePreferences,
+  };
+};

package/src/infrastructure/hooks/useNotifications.ts

@@ -1,8 +1,10 @@
-import { useEffect } from 'react';
+import { useEffect, useCallback } from 'react';
 import { useNotificationsState } from './state/useNotificationsState';
 import { useNotificationActions } from './actions/useNotificationActions';
+import { useNotificationManagementActions } from './actions/useNotificationManagementActions';
 import { useNotificationRefresh } from './utils/useNotificationRefresh';
 import type { UseNotificationsOptions } from './types';
+import { devLog } from '../utils/dev';
 
 export * from './types';
 
@@ -31,10 +33,25 @@ export function useNotifications(userId: string, options: UseNotificationsOption
   };
 
   const actions = useNotificationActions(state, setters);
+  const managementActions = useNotificationManagementActions(state, setters);
   const refresh = useNotificationRefresh(pageSize, setters);
 
-  const loadMoreNotifications = () => 
-    refresh.loadMoreNotifications(state.notifications.length, state.hasMore, state.loading);
+  const loadMoreNotifications = useCallback(() => 
+    refresh.loadMoreNotifications(state.notifications.length, state.hasMore, state.loading),
+    [refresh, state.notifications.length, state.hasMore, state.loading]
+  );
+
+  const cleanup = useCallback(() => {
+    setNotifications([]);
+    setChannels([]);
+    setUnreadCount(0);
+    setPreferences(null);
+    setError(null);
+    setLoading(false);
+    setHasMore(true);
+
+    devLog('[useNotifications] Cleaned up notification state');
+  }, [setNotifications, setChannels, setUnreadCount, setPreferences, setError, setLoading, setHasMore]);
 
   // Load initial data
   useEffect(() => {
@@ -43,14 +60,11 @@ export function useNotifications(userId: string, options: UseNotificationsOption
       refresh.refreshChannels();
       refresh.refreshPreferences();
     } else {
-      setNotifications([]);
-      setChannels([]);
-      setUnreadCount(0);
-      setPreferences(null);
+      cleanup();
     }
-  }, [userId]);
+  }, [userId, cleanup]);
 
-  // Auto-refresh setup
+  // Auto-refresh setup with proper cleanup
   useEffect(() => {
     if (!autoRefresh || !userId) return;
 
@@ -58,13 +72,25 @@ export function useNotifications(userId: string, options: UseNotificationsOption
       refresh.refreshNotifications();
     }, refreshInterval);
 
-    return () => clearInterval(interval);
+    return () => {
+      clearInterval(interval);
+      devLog('[useNotifications] Auto-refresh interval cleared');
+    };
   }, [autoRefresh, userId, refreshInterval]);
 
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      devLog('[useNotifications] Component unmounted, cleaning up');
+    };
+  }, []);
+
   return {
     ...state,
     ...actions,
+    ...managementActions,
     ...refresh,
     loadMoreNotifications,
+    cleanup,
   };
-}
+}

package/src/infrastructure/hooks/utils/useNotificationRefresh.ts

@@ -1,15 +1,10 @@
-import { useCallback } from 'react';
+import { useCallback, useRef } from 'react';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import type { Notification } from '../types';
 import { ChannelManager } from '../../services/channels/ChannelManager';
 import { PreferencesManager } from '../../services/preferences/PreferencesManager';
+import { devLog, devError } from '../../utils/dev';
 
-/**
- * useNotificationRefresh - Offline Notification Refresh
- *
- * Uses AsyncStorage for local data.
- * NO backend - pure offline.
- */
 export const useNotificationRefresh = (pageSize: number, setters: any) => {
   const {
     setNotifications,
@@ -21,39 +16,57 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
     setHasMore,
   } = setters;
 
-  const channelManager = new ChannelManager();
-  const preferencesManager = new PreferencesManager();
+  const channelManager = useRef(new ChannelManager()).current;
+  const preferencesManager = useRef(new PreferencesManager()).current;
+  const abortController = useRef<AbortController | null>(null);
+
+  const cleanup = useCallback(() => {
+    if (abortController.current) {
+      abortController.current.abort();
+      abortController.current = null;
+    }
+  }, []);
 
   const refreshNotifications = useCallback(async () => {
     try {
+      cleanup();
+      abortController.current = new AbortController();
+
       setLoading(true);
       setError(null);
 
-      // Load from AsyncStorage
       const data = await AsyncStorage.getItem('@notifications:list');
       const allNotifications: Notification[] = data ? JSON.parse(data) : [];
 
-      // Paginate
       const paginated = allNotifications.slice(0, pageSize);
       const unread = allNotifications.filter((n) => !n.read).length;
 
       setNotifications(paginated);
       setUnreadCount(unread);
       setHasMore(allNotifications.length > pageSize);
+
+      devLog('[useNotificationRefresh] Refreshed notifications:', paginated.length);
     } catch (err) {
+      if (err instanceof Error && err.name === 'AbortError') {
+        return;
+      }
       setError(
         err instanceof Error ? err.message : 'Failed to load notifications'
       );
     } finally {
       setLoading(false);
+      cleanup();
     }
-  }, [pageSize, setNotifications, setUnreadCount, setHasMore, setLoading, setError]);
+  }, [pageSize, setNotifications, setUnreadCount, setHasMore, setLoading, setError, cleanup]);
 
   const loadMoreNotifications = useCallback(
     async (currentLength: number, hasMore: boolean, loading: boolean) => {
       if (!hasMore || loading) return;
 
       try {
+        cleanup();
+        abortController.current = new AbortController();
+
         setLoading(true);
         setError(null);
 
@@ -67,7 +80,12 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
 
         setNotifications((prev: any[]) => [...prev, ...moreNotifications]);
         setHasMore(allNotifications.length > currentLength + pageSize);
+
+        devLog('[useNotificationRefresh] Loaded more notifications:', moreNotifications.length);
       } catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+          return;
+        }
         setError(
           err instanceof Error
             ? err.message
@@ -75,17 +93,20 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
         );
       } finally {
         setLoading(false);
+        cleanup();
       }
     },
-    [pageSize, setNotifications, setHasMore, setLoading, setError]
+    [pageSize, setNotifications, setHasMore, setLoading, setError, cleanup]
   );
 
   const refreshChannels = useCallback(async () => {
     try {
       const channelsData = await channelManager.getActiveChannels();
       setChannels(channelsData);
+
+      devLog('[useNotificationRefresh] Refreshed channels:', channelsData.length);
     } catch (err) {
-      // Silent failure
+      devError('[useNotificationRefresh] Failed to refresh channels:', err);
     }
   }, [setChannels]);
 
@@ -93,8 +114,10 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
     try {
       const prefsData = await preferencesManager.get();
       setPreferences(prefsData);
+
+      devLog('[useNotificationRefresh] Refreshed preferences');
     } catch (err) {
-      // Silent failure
+      devError('[useNotificationRefresh] Failed to refresh preferences:', err);
     }
   }, [setPreferences]);
 
@@ -103,5 +126,6 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
     loadMoreNotifications,
     refreshChannels,
     refreshPreferences,
+    cleanup,
   };
-};
+};

package/src/infrastructure/services/NotificationBadgeManager.ts

@@ -0,0 +1,28 @@
+import * as Notifications from 'expo-notifications';
+import { Platform } from 'react-native';
+import { devError } from '../utils/dev';
+
+export class NotificationBadgeManager {
+  async getBadgeCount(): Promise<number> {
+    try {
+      if (Platform.OS === 'ios') {
+        return await Notifications.getBadgeCountAsync();
+      }
+      return 0;
+    } catch (error) {
+      devError('[NotificationBadgeManager] Get badge count failed:', error);
+      return 0;
+    }
+  }
+
+  async setBadgeCount(count: number): Promise<void> {
+    try {
+      if (Platform.OS === 'ios') {
+        await Notifications.setBadgeCountAsync(count);
+      }
+    } catch (error) {
+      devError('[NotificationBadgeManager] Set badge count failed:', error);
+      throw error;
+    }
+  }
+}