@umituz/react-native-notifications 1.1.7 → 1.3.0

package/src/__tests__/useNotificationRefresh.test.ts

@@ -1,213 +0,0 @@
-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/infrastructure/hooks/actions/useNotificationActions.ts

@@ -1,131 +0,0 @@
-import { useCallback } from 'react';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import * as Notifications from 'expo-notifications';
-import type {
-  SendNotificationOptions,
-  Notification,
-  NotificationChannel,
-  NotificationPreferences,
-} from '../types';
-import { NotificationDelivery } from '../../services/delivery/NotificationDelivery';
-import { ChannelManager } from '../../services/channels/ChannelManager';
-import { PreferencesManager } from '../../services/preferences/PreferencesManager';
-import { devLog } from '../../utils/dev';
-
-export const useNotificationActions = (state: any, setters: any) => {
-  const {
-    setNotifications,
-    setUnreadCount,
-    setChannels,
-    setPreferences,
-    setError,
-  } = setters;
-
-  const notificationDelivery = new NotificationDelivery();
-  const channelManager = new ChannelManager();
-  const preferencesManager = new PreferencesManager();
-
-  const sendNotification = useCallback(
-    async (options: SendNotificationOptions): Promise<Notification[]> => {
-      try {
-        setError(null);
-
-        const notification: Notification = {
-          id: `notif_${Date.now()}`,
-          title: options.title,
-          body: options.body,
-          data: options.data,
-          scheduled_for: options.scheduled_for?.toISOString(),
-          created_at: new Date().toISOString(),
-          read: false,
-        };
-
-        const data = await AsyncStorage.getItem('@notifications:list');
-        const notifications: Notification[] = data ? JSON.parse(data) : [];
-        notifications.unshift(notification);
-        await AsyncStorage.setItem(
-          '@notifications:list',
-          JSON.stringify(notifications)
-        );
-
-        await notificationDelivery.deliver(notification);
-
-        devLog('[useNotificationActions] Notification sent:', notification.id);
-
-        return [notification];
-      } catch (err) {
-        setError(
-          err instanceof Error ? err.message : 'Failed to send notification'
-        );
-        return [];
-      }
-    },
-    [setError]
-  );
-
-  const markAsRead = useCallback(
-    async (notificationId: string): Promise<boolean> => {
-      try {
-        const data = await AsyncStorage.getItem('@notifications:list');
-        const notifications: Notification[] = data ? JSON.parse(data) : [];
-
-        const updated = notifications.map((n) =>
-          n.id === notificationId ? { ...n, read: true } : n
-        );
-
-        await AsyncStorage.setItem(
-          '@notifications:list',
-          JSON.stringify(updated)
-        );
-
-        setNotifications((prev: Notification[]) =>
-          prev.map((n) =>
-            n.id === notificationId ? { ...n, read: true } : n
-          )
-        );
-        setUnreadCount((prev: number) => Math.max(0, prev - 1));
-
-        devLog('[useNotificationActions] Marked as read:', notificationId);
-
-        return true;
-      } catch (err) {
-        setError(
-          err instanceof Error ? err.message : 'Failed to mark as read'
-        );
-        return false;
-      }
-    },
-    [setNotifications, setUnreadCount, setError]
-  );
-
-  const markAllAsRead = useCallback(async (): Promise<boolean> => {
-    try {
-      const data = await AsyncStorage.getItem('@notifications:list');
-      const notifications: Notification[] = data ? JSON.parse(data) : [];
-
-      const updated = notifications.map((n) => ({ ...n, read: true }));
-
-      await AsyncStorage.setItem('@notifications:list', JSON.stringify(updated));
-
-      setNotifications((prev: Notification[]) =>
-        prev.map((n) => ({ ...n, read: true }))
-      );
-      setUnreadCount(0);
-
-      devLog('[useNotificationActions] All notifications marked as read');
-
-      return true;
-    } catch (err) {
-      setError(
-        err instanceof Error ? err.message : 'Failed to mark all as read'
-      );
-      return false;
-    }
-  }, [setNotifications, setUnreadCount, setError]);
-
-  return {
-    sendNotification,
-    markAsRead,
-    markAllAsRead,
-  };
-};

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

@@ -1,131 +0,0 @@
-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/state/useNotificationsState.ts

@@ -1,46 +0,0 @@
-import { useState } from 'react';
-import type { NotificationsState } from '../types';
-
-export const useNotificationsState = () => {
-  const [state, setState] = useState<NotificationsState>({
-    notifications: [],
-    channels: [],
-    unreadCount: 0,
-    preferences: null,
-    loading: false,
-    error: null,
-    hasMore: true,
-  });
-
-  const setNotifications = (notifications: NotificationsState['notifications']) =>
-    setState(prev => ({ ...prev, notifications }));
-
-  const setChannels = (channels: NotificationsState['channels']) =>
-    setState(prev => ({ ...prev, channels }));
-
-  const setUnreadCount = (unreadCount: number) =>
-    setState(prev => ({ ...prev, unreadCount }));
-
-  const setPreferences = (preferences: NotificationsState['preferences']) =>
-    setState(prev => ({ ...prev, preferences }));
-
-  const setLoading = (loading: boolean) =>
-    setState(prev => ({ ...prev, loading }));
-
-  const setError = (error: string | null) =>
-    setState(prev => ({ ...prev, error }));
-
-  const setHasMore = (hasMore: boolean) =>
-    setState(prev => ({ ...prev, hasMore }));
-
-  return {
-    state,
-    setNotifications,
-    setChannels,
-    setUnreadCount,
-    setPreferences,
-    setLoading,
-    setError,
-    setHasMore,
-  };
-};

package/src/infrastructure/hooks/types.ts

@@ -1,83 +0,0 @@
-/**
- * Notification Hook Types - Offline-First
- *
- * All types for offline local notifications.
- * NO backend dependencies.
- */
-
-/**
- * Local notification entity
- */
-export interface Notification {
-  id: string;
-  title: string;
-  body: string;
-  data?: Record<string, any>;
-  scheduled_for?: string;
-  created_at: string;
-  read: boolean;
-}
-
-/**
- * Notification channel (push or in-app only)
- */
-export interface NotificationChannel {
-  id: string;
-  channel_type: 'push' | 'in_app';
-  channel_address: string;
-  preferences: Record<string, any>;
-  is_verified: boolean;
-  is_active: boolean;
-  created_at: string;
-}
-
-/**
- * Notification preferences
- */
-export interface NotificationPreferences {
-  push_enabled: boolean;
-  quiet_hours: {
-    enabled: boolean;
-    start_time: string;
-    end_time: string;
-    timezone: string;
-  };
-  categories: {
-    reminders: { push: boolean; in_app: boolean };
-    updates: { push: boolean; in_app: boolean };
-    alerts: { push: boolean; in_app: boolean };
-  };
-}
-
-/**
- * Options for sending notification
- */
-export interface SendNotificationOptions {
-  title: string;
-  body: string;
-  data?: Record<string, any>;
-  scheduled_for?: Date;
-  category?: 'reminders' | 'updates' | 'alerts';
-}
-
-/**
- * State for useNotifications hook
- */
-export interface NotificationsState {
-  notifications: Notification[];
-  channels: NotificationChannel[];
-  unreadCount: number;
-  preferences: NotificationPreferences | null;
-  loading: boolean;
-  error: string | null;
-  hasMore: boolean;
-}
-
-/**
- * Options for useNotifications hook
- */
-export interface UseNotificationsOptions {
-  autoRefresh?: boolean;
-  refreshInterval?: number;
-  pageSize?: number;
-}

package/src/infrastructure/hooks/useNotifications.ts

@@ -1,96 +0,0 @@
-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';
-
-export function useNotifications(userId: string, options: UseNotificationsOptions = {}) {
-  const { autoRefresh = false, refreshInterval = 30000, pageSize = 20 } = options;
-
-  const {
-    state,
-    setNotifications,
-    setChannels,
-    setUnreadCount,
-    setPreferences,
-    setLoading,
-    setError,
-    setHasMore,
-  } = useNotificationsState();
-
-  const setters = {
-    setNotifications,
-    setChannels,
-    setUnreadCount,
-    setPreferences,
-    setLoading,
-    setError,
-    setHasMore,
-  };
-
-  const actions = useNotificationActions(state, setters);
-  const managementActions = useNotificationManagementActions(state, setters);
-  const refresh = useNotificationRefresh(pageSize, setters);
-
-  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(() => {
-    if (userId) {
-      refresh.refreshNotifications();
-      refresh.refreshChannels();
-      refresh.refreshPreferences();
-    } else {
-      cleanup();
-    }
-  }, [userId, cleanup]);
-
-  // Auto-refresh setup with proper cleanup
-  useEffect(() => {
-    if (!autoRefresh || !userId) return;
-
-    const interval = setInterval(() => {
-      refresh.refreshNotifications();
-    }, refreshInterval);
-
-    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,
-  };
-}