@umituz/react-native-notifications 1.0.0

package/src/infrastructure/services/NotificationManager.ts

@@ -0,0 +1,326 @@
+/**
+ * NotificationManager
+ *
+ * Offline-first notification system using expo-notifications.
+ * Works in ALL apps (offline, online, hybrid) - no backend required.
+ *
+ * Features:
+ * - Schedule notifications for specific dates/times
+ * - Repeating notifications (daily, weekly, monthly)
+ * - Android notification channels
+ * - Permission handling
+ * - Cancel individual or all notifications
+ * - Works completely offline
+ *
+ * Use Cases:
+ * - Reminders (bills, tasks, appointments)
+ * - Habit tracking (daily streaks)
+ * - Medication reminders
+ * - Any app needing local notifications
+ *
+ * @module NotificationManager
+ */
+
+import * as Notifications from 'expo-notifications';
+import * as Device from 'expo-device';
+import { Platform } from 'react-native';
+
+/**
+ * Trigger types for notifications
+ */
+export type NotificationTrigger =
+  | { type: 'date'; date: Date }
+  | { type: 'daily'; hour: number; minute: number }
+  | { type: 'weekly'; weekday: number; hour: number; minute: number }
+  | { type: 'monthly'; day: number; hour: number; minute: number };
+
+/**
+ * Options for scheduling a notification
+ */
+export interface ScheduleNotificationOptions {
+  title: string;
+  body: string;
+  data?: Record<string, any>;
+  trigger: NotificationTrigger;
+  sound?: boolean | string;
+  badge?: number;
+  categoryIdentifier?: string;
+}
+
+/**
+ * Scheduled notification details
+ */
+export interface ScheduledNotification {
+  identifier: string;
+  content: {
+    title: string;
+    body: string;
+    data: Record<string, any>;
+  };
+  trigger: any;
+}
+
+/**
+ * NotificationManager
+ *
+ * Handles all notification operations using expo-notifications.
+ * Works completely offline - no backend, no user IDs, just device-local notifications.
+ */
+export class NotificationManager {
+  /**
+   * Configure notification handler (how notifications appear when app is in foreground)
+   */
+  static configure() {
+    Notifications.setNotificationHandler({
+      handleNotification: async () => ({
+        shouldShowAlert: true,
+        shouldPlaySound: true,
+        shouldSetBadge: true,
+      }),
+    });
+  }
+
+  /**
+   * Request notification permissions
+   * iOS: Shows system permission dialog
+   * Android: Permissions granted by default (Android 13+ requires runtime permission)
+   */
+  async requestPermissions(): Promise<boolean> {
+    try {
+      if (!Device.isDevice) {
+        console.warn('[NotificationManager] Notifications only work on physical devices');
+        return false;
+      }
+
+      const { status: existingStatus } = await Notifications.getPermissionsAsync();
+      let finalStatus = existingStatus;
+
+      if (existingStatus !== 'granted') {
+        const { status } = await Notifications.requestPermissionsAsync();
+        finalStatus = status;
+      }
+
+      if (Platform.OS === 'android') {
+        await this.createAndroidChannels();
+      }
+
+      return finalStatus === 'granted';
+    } catch (error) {
+      console.error('[NotificationManager] Permission request failed:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check if notification permissions are granted
+   */
+  async hasPermissions(): Promise<boolean> {
+    try {
+      if (!Device.isDevice) return false;
+      const { status } = await Notifications.getPermissionsAsync();
+      return status === 'granted';
+    } catch (error) {
+      console.error('[NotificationManager] Permission check failed:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Create Android notification channels (required for Android 8+)
+   */
+  private async createAndroidChannels(): Promise<void> {
+    if (Platform.OS !== 'android') return;
+
+    try {
+      await Notifications.setNotificationChannelAsync('default', {
+        name: 'Default',
+        importance: Notifications.AndroidImportance.DEFAULT,
+        vibrationPattern: [0, 250, 250, 250],
+        sound: 'default',
+        lightColor: '#3B82F6',
+      });
+
+      await Notifications.setNotificationChannelAsync('reminders', {
+        name: 'Reminders',
+        importance: Notifications.AndroidImportance.HIGH,
+        vibrationPattern: [0, 250, 250, 250],
+        sound: 'default',
+        lightColor: '#3B82F6',
+        enableVibrate: true,
+      });
+
+      await Notifications.setNotificationChannelAsync('urgent', {
+        name: 'Urgent',
+        importance: Notifications.AndroidImportance.MAX,
+        vibrationPattern: [0, 500, 250, 500],
+        sound: 'default',
+        lightColor: '#EF4444',
+        enableVibrate: true,
+      });
+    } catch (error) {
+      console.error('[NotificationManager] Android channel creation failed:', error);
+    }
+  }
+
+  /**
+   * Schedule a notification
+   *
+   * @example
+   * // Specific date
+   * const id = await manager.scheduleNotification({
+   *   title: 'Bill Reminder',
+   *   body: 'Electricity bill due today',
+   *   trigger: { type: 'date', date: new Date('2025-01-15T09:00:00') }
+   * });
+   *
+   * @example
+   * // Daily reminder
+   * const id = await manager.scheduleNotification({
+   *   title: 'Daily Workout',
+   *   body: 'Time for your morning workout!',
+   *   trigger: { type: 'daily', hour: 7, minute: 0 }
+   * });
+   */
+  async scheduleNotification(options: ScheduleNotificationOptions): Promise<string> {
+    try {
+      const { title, body, data = {}, trigger, sound = true, badge, categoryIdentifier } = options;
+
+      let notificationTrigger: any;
+
+      if (trigger.type === 'date') {
+        notificationTrigger = {
+          date: trigger.date,
+          channelId: categoryIdentifier || 'default',
+        };
+      } else if (trigger.type === 'daily') {
+        notificationTrigger = {
+          hour: trigger.hour,
+          minute: trigger.minute,
+          repeats: true,
+          channelId: categoryIdentifier || 'reminders',
+        };
+      } else if (trigger.type === 'weekly') {
+        notificationTrigger = {
+          weekday: trigger.weekday,
+          hour: trigger.hour,
+          minute: trigger.minute,
+          repeats: true,
+          channelId: categoryIdentifier || 'reminders',
+        };
+      } else if (trigger.type === 'monthly') {
+        notificationTrigger = {
+          day: trigger.day,
+          hour: trigger.hour,
+          minute: trigger.minute,
+          repeats: true,
+          channelId: categoryIdentifier || 'reminders',
+        };
+      }
+
+      const notificationId = await Notifications.scheduleNotificationAsync({
+        content: {
+          title,
+          body,
+          data,
+          sound: sound === true ? 'default' : sound || undefined,
+          badge,
+          categoryIdentifier,
+          priority: Notifications.AndroidNotificationPriority.HIGH,
+          vibrate: [0, 250, 250, 250],
+        },
+        trigger: notificationTrigger,
+      });
+
+      return notificationId;
+    } catch (error) {
+      console.error('[NotificationManager] Schedule notification failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Cancel a scheduled notification
+   */
+  async cancelNotification(notificationId: string): Promise<void> {
+    try {
+      await Notifications.cancelScheduledNotificationAsync(notificationId);
+    } catch (error) {
+      console.error('[NotificationManager] Cancel notification failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Cancel all scheduled notifications
+   */
+  async cancelAllNotifications(): Promise<void> {
+    try {
+      await Notifications.cancelAllScheduledNotificationsAsync();
+    } catch (error) {
+      console.error('[NotificationManager] Cancel all notifications failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get all scheduled notifications
+   */
+  async getScheduledNotifications(): Promise<ScheduledNotification[]> {
+    try {
+      const notifications = await Notifications.getAllScheduledNotificationsAsync();
+      return notifications.map(notification => ({
+        identifier: notification.identifier,
+        content: {
+          title: notification.content.title || '',
+          body: notification.content.body || '',
+          data: notification.content.data as Record<string, any>,
+        },
+        trigger: notification.trigger,
+      }));
+    } catch (error) {
+      console.error('[NotificationManager] Get scheduled notifications failed:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Dismiss all delivered notifications (clear from notification center)
+   */
+  async dismissAllNotifications(): Promise<void> {
+    try {
+      await Notifications.dismissAllNotificationsAsync();
+    } catch (error) {
+      console.error('[NotificationManager] Dismiss all notifications failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get notification badge count (iOS only)
+   */
+  async getBadgeCount(): Promise<number> {
+    try {
+      if (Platform.OS === 'ios') {
+        return await Notifications.getBadgeCountAsync();
+      }
+      return 0;
+    } catch (error) {
+      console.error('[NotificationManager] Get badge count failed:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Set notification badge count (iOS only)
+   */
+  async setBadgeCount(count: number): Promise<void> {
+    try {
+      if (Platform.OS === 'ios') {
+        await Notifications.setBadgeCountAsync(count);
+      }
+    } catch (error) {
+      console.error('[NotificationManager] Set badge count failed:', error);
+      throw error;
+    }
+  }
+}

package/src/infrastructure/services/NotificationService.ts

@@ -0,0 +1,50 @@
+/**
+ * NotificationService
+ *
+ * Simple facade for offline notification system.
+ * Works in ALL apps - offline, online, hybrid - no backend required.
+ *
+ * @module NotificationService
+ */
+
+import { NotificationManager } from './NotificationManager';
+
+export * from './types';
+
+/**
+ * Notification service singleton
+ * Provides simple access to notification manager
+ */
+export class NotificationService {
+  private static instance: NotificationService;
+
+  readonly notifications = new NotificationManager();
+
+  private constructor() {
+    // Configure notification handler on initialization
+    NotificationManager.configure();
+  }
+
+  static getInstance(): NotificationService {
+    if (!NotificationService.instance) {
+      NotificationService.instance = new NotificationService();
+    }
+    return NotificationService.instance;
+  }
+
+  /**
+   * Request notification permissions
+   */
+  async requestPermissions(): Promise<boolean> {
+    return await this.notifications.requestPermissions();
+  }
+
+  /**
+   * Check if permissions are granted
+   */
+  async hasPermissions(): Promise<boolean> {
+    return await this.notifications.hasPermissions();
+  }
+}
+
+export const notificationService = NotificationService.getInstance();

package/src/infrastructure/services/channels/ChannelManager.ts

@@ -0,0 +1,111 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import * as Notifications from 'expo-notifications';
+import type { NotificationChannel } from '../types';
+
+/**
+ * ChannelManager - Offline Notification Channel Management
+ *
+ * Manages push notification tokens and preferences in AsyncStorage.
+ * Only supports local push and in-app notifications.
+ *
+ * NO backend, NO email/SMS - pure offline.
+ */
+export class ChannelManager {
+  private static STORAGE_KEY = '@notifications:channels';
+
+  async register(
+    channelType: 'push' | 'in_app',
+    preferences: Record<string, any> = {}
+  ): Promise<NotificationChannel | null> {
+    try {
+      // Get push token for local notifications
+      const token =
+        channelType === 'push'
+          ? (await Notifications.getExpoPushTokenAsync()).data
+          : 'in_app';
+
+      const channel: NotificationChannel = {
+        id: `${channelType}_${Date.now()}`,
+        channel_type: channelType,
+        channel_address: token,
+        preferences,
+        is_verified: true, // Local channels always verified
+        is_active: true,
+        created_at: new Date().toISOString(),
+      };
+
+      // Store in AsyncStorage
+      const channels = await this.getAllChannels();
+      channels.push(channel);
+      await AsyncStorage.setItem(
+        ChannelManager.STORAGE_KEY,
+        JSON.stringify(channels)
+      );
+
+      return channel;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async verify(channelId: string): Promise<boolean> {
+    try {
+      const channels = await this.getAllChannels();
+      const index = channels.findIndex((c) => c.id === channelId);
+
+      if (index !== -1) {
+        channels[index].is_verified = true;
+        await AsyncStorage.setItem(
+          ChannelManager.STORAGE_KEY,
+          JSON.stringify(channels)
+        );
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async getActiveChannels(): Promise<NotificationChannel[]> {
+    try {
+      const channels = await this.getAllChannels();
+      return channels.filter((c) => c.is_active && c.is_verified);
+    } catch (error) {
+      return [];
+    }
+  }
+
+  private async getAllChannels(): Promise<NotificationChannel[]> {
+    try {
+      const data = await AsyncStorage.getItem(ChannelManager.STORAGE_KEY);
+      return data ? JSON.parse(data) : [];
+    } catch (error) {
+      return [];
+    }
+  }
+
+  private async update(
+    channelId: string,
+    updates: Partial<NotificationChannel>
+  ): Promise<NotificationChannel | null> {
+    try {
+      const channels = await this.getAllChannels();
+      const index = channels.findIndex((c) => c.id === channelId);
+
+      if (index !== -1) {
+        channels[index] = { ...channels[index], ...updates };
+        await AsyncStorage.setItem(
+          ChannelManager.STORAGE_KEY,
+          JSON.stringify(channels)
+        );
+        return channels[index];
+      }
+
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+}

package/src/infrastructure/services/delivery/NotificationDelivery.ts

@@ -0,0 +1,65 @@
+import * as Notifications from 'expo-notifications';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { Notification } from '../types';
+
+/**
+ * NotificationDelivery - Offline Local Notification Delivery
+ *
+ * Uses expo-notifications for local push notifications only.
+ * All data stored in AsyncStorage (offline-capable).
+ *
+ * NO backend, NO email/SMS - pure offline local notifications.
+ */
+export class NotificationDelivery {
+  private static STORAGE_KEY = '@notifications:delivered';
+
+  async deliver(notification: Notification): Promise<void> {
+    try {
+      // Schedule local notification using expo-notifications
+      await Notifications.scheduleNotificationAsync({
+        content: {
+          title: notification.title,
+          body: notification.body,
+          data: { notificationId: notification.id },
+        },
+        trigger: notification.scheduled_for
+          ? { date: new Date(notification.scheduled_for) }
+          : null, // null = immediate delivery
+      });
+
+      // Update status in AsyncStorage (offline storage)
+      await this.updateStatus(notification.id, 'delivered');
+    } catch (error) {
+      // Silent failure - update status to failed
+      await this.updateStatus(notification.id, 'failed');
+    }
+  }
+
+  private async updateStatus(
+    notificationId: string,
+    status: 'delivered' | 'failed'
+  ): Promise<void> {
+    try {
+      const delivered = await this.getDelivered();
+      delivered[notificationId] = {
+        status,
+        delivered_at: new Date().toISOString(),
+      };
+      await AsyncStorage.setItem(
+        NotificationDelivery.STORAGE_KEY,
+        JSON.stringify(delivered)
+      );
+    } catch (error) {
+      // Silent failure
+    }
+  }
+
+  private async getDelivered(): Promise<Record<string, any>> {
+    try {
+      const data = await AsyncStorage.getItem(NotificationDelivery.STORAGE_KEY);
+      return data ? JSON.parse(data) : {};
+    } catch (error) {
+      return {};
+    }
+  }
+}

package/src/infrastructure/services/preferences/PreferencesManager.ts

@@ -0,0 +1,77 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { NotificationPreferences } from '../types';
+
+/**
+ * PreferencesManager - Offline Notification Preferences
+ *
+ * Stores preferences in AsyncStorage (offline-capable).
+ * Only supports local push and in-app notifications.
+ *
+ * NO backend, NO email/SMS - pure offline.
+ */
+export class PreferencesManager {
+  private static STORAGE_KEY = '@notifications:preferences';
+
+  async get(): Promise<NotificationPreferences> {
+    try {
+      const data = await AsyncStorage.getItem(PreferencesManager.STORAGE_KEY);
+      return data ? JSON.parse(data) : this.getDefaults();
+    } catch (error) {
+      return this.getDefaults();
+    }
+  }
+
+  async update(preferences: Partial<NotificationPreferences>): Promise<boolean> {
+    try {
+      const current = await this.get();
+      const updated = {
+        ...current,
+        ...preferences,
+        categories: { ...current.categories, ...preferences.categories },
+      };
+
+      await AsyncStorage.setItem(
+        PreferencesManager.STORAGE_KEY,
+        JSON.stringify(updated)
+      );
+
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  isChannelEnabled(
+    channelType: 'push' | 'in_app',
+    prefs: NotificationPreferences
+  ): boolean {
+    if (channelType === 'in_app') return true;
+    return prefs.push_enabled ?? true;
+  }
+
+  isInQuietHours(quietHours: NotificationPreferences['quiet_hours']): boolean {
+    if (!quietHours.enabled) return false;
+    const currentTime = new Date().toTimeString().slice(0, 5);
+    return (
+      currentTime >= quietHours.start_time ||
+      currentTime <= quietHours.end_time
+    );
+  }
+
+  private getDefaults(): NotificationPreferences {
+    return {
+      push_enabled: true,
+      quiet_hours: {
+        enabled: false,
+        start_time: '22:00',
+        end_time: '08:00',
+        timezone: 'UTC',
+      },
+      categories: {
+        reminders: { push: true, in_app: true },
+        updates: { push: true, in_app: true },
+        alerts: { push: true, in_app: true },
+      },
+    };
+  }
+}

package/src/infrastructure/services/types.ts

@@ -0,0 +1,81 @@
+/**
+ * Offline-First Notification Types
+ * Uses expo-notifications for local device notifications
+ * NO backend, NO user IDs, NO push notifications
+ */
+
+/**
+ * Notification channel for managing notification delivery
+ */
+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 data structure
+ */
+export interface Notification {
+  id: string;
+  title: string;
+  body: string;
+  scheduled_for?: string;
+  data?: Record<string, any>;
+}
+
+/**
+ * User notification preferences
+ */
+export interface NotificationPreferences {
+  push_enabled: boolean;
+  quiet_hours: {
+    enabled: boolean;
+    start_time: string;
+    end_time: string;
+    timezone: string;
+  };
+  categories: Record<string, {
+    push: boolean;
+    in_app: boolean;
+  }>;
+}
+
+/**
+ * Trigger types for scheduling notifications
+ */
+export type NotificationTrigger =
+  | { type: 'date'; date: Date }
+  | { type: 'daily'; hour: number; minute: number }
+  | { type: 'weekly'; weekday: number; hour: number; minute: number }
+  | { type: 'monthly'; day: number; hour: number; minute: number };
+
+/**
+ * Options for scheduling a notification
+ */
+export interface ScheduleNotificationOptions {
+  title: string;
+  body: string;
+  data?: Record<string, any>;
+  trigger: NotificationTrigger;
+  sound?: boolean | string;
+  badge?: number;
+  categoryIdentifier?: string;
+}
+
+/**
+ * Scheduled notification details
+ */
+export interface ScheduledNotification {
+  identifier: string;
+  content: {
+    title: string;
+    body: string;
+    data: Record<string, any>;
+  };
+  trigger: any;
+}