@umituz/react-native-subscription 1.1.1 → 1.3.0

package/src/presentation/hooks/useUserTierWithRepository.ts

@@ -0,0 +1,171 @@
+/**
+ * useUserTierWithRepository Hook
+ *
+ * Complete hook that automatically fetches premium status from repository
+ * and provides user tier information. This eliminates the need for app-specific
+ * useUserTier wrappers.
+ *
+ * This hook combines:
+ * - Auth state (from AuthProvider)
+ * - Premium status fetching (from ISubscriptionRepository)
+ * - Tier logic (from useUserTier)
+ *
+ * @example
+ * ```typescript
+ * import { useUserTierWithRepository } from '@umituz/react-native-premium';
+ * import { useAuth } from '@domains/auth';
+ * import { premiumRepository } from '@/infrastructure/repositories/PremiumRepository';
+ *
+ * const { tier, isPremium, isGuest, isLoading, refresh } = useUserTierWithRepository({
+ *   auth: useAuth(),
+ *   repository: premiumRepository,
+ * });
+ * ```
+ */
+
+import { useEffect, useState, useCallback } from 'react';
+import { useUserTier, type UseUserTierParams } from './useUserTier';
+import type { ISubscriptionRepository } from '../../application/ports/ISubscriptionRepository';
+
+/**
+ * Auth provider interface
+ * Apps should provide an object that matches this interface
+ */
+export interface AuthProvider {
+  /** Current user object (null for guests) */
+  user: { uid: string } | null;
+  /** Whether user is a guest */
+  isGuest: boolean;
+  /** Whether user is authenticated */
+  isAuthenticated: boolean;
+}
+
+export interface UseUserTierWithRepositoryParams {
+  /** Auth provider (e.g., result of useAuth hook) */
+  auth: AuthProvider;
+  /** Subscription repository for fetching premium status */
+  repository: ISubscriptionRepository;
+}
+
+export interface UseUserTierWithRepositoryResult {
+  /** User tier: 'guest' | 'freemium' | 'premium' */
+  tier: 'guest' | 'freemium' | 'premium';
+  /** Whether user has premium access */
+  isPremium: boolean;
+  /** Whether user is a guest */
+  isGuest: boolean;
+  /** Whether user is authenticated */
+  isAuthenticated: boolean;
+  /** User ID (null for guests) */
+  userId: string | null;
+  /** Whether premium status is currently loading */
+  isLoading: boolean;
+  /** Premium status error (if any) */
+  error: string | null;
+  /** Refresh premium status from repository */
+  refresh: () => Promise<void>;
+}
+
+/**
+ * Hook that automatically fetches premium status and provides user tier information
+ * 
+ * This hook eliminates the need for app-specific useUserTier wrappers by:
+ * 1. Automatically fetching premium status from repository
+ * 2. Handling loading and error states
+ * 3. Providing refresh functionality
+ * 4. Using centralized tier logic from useUserTier
+ */
+export function useUserTierWithRepository(
+  params: UseUserTierWithRepositoryParams,
+): UseUserTierWithRepositoryResult {
+  const { auth, repository } = params;
+  const { user, isGuest, isAuthenticated } = auth;
+
+  const [isPremium, setIsPremium] = useState<boolean>(false);
+  const [isLoading, setIsLoading] = useState<boolean>(true);
+  const [error, setError] = useState<string | null>(null);
+
+  // Fetch premium status from repository
+  const fetchPremiumStatus = useCallback(async (signal?: AbortSignal) => {
+    // Guest users are never premium - no need to fetch
+    if (!isAuthenticated || !user) {
+      setIsPremium(false);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+
+    try {
+      setIsLoading(true);
+      setError(null);
+
+      const status = await repository.getSubscriptionStatus(user.uid);
+      
+      // Check if operation was aborted
+      if (signal?.aborted) {
+        return;
+      }
+
+      const isPremiumValue =
+        status !== null && repository.isSubscriptionValid(status);
+
+      // Check again before setting state
+      if (!signal?.aborted) {
+        setIsPremium(isPremiumValue);
+        setIsLoading(false);
+      }
+    } catch (err) {
+      // Don't set state if operation was aborted
+      if (!signal?.aborted) {
+        const errorMessage =
+          err instanceof Error ? err.message : 'Failed to fetch premium status';
+        setError(errorMessage);
+        setIsPremium(false);
+        setIsLoading(false);
+      }
+    }
+  }, [isAuthenticated, user, repository]);
+
+  // Fetch premium status when auth state changes
+  useEffect(() => {
+    const abortController = new AbortController();
+
+    fetchPremiumStatus(abortController.signal).catch(() => {
+      // Error is handled in fetchPremiumStatus
+    });
+
+    return () => {
+      abortController.abort();
+    };
+  }, [fetchPremiumStatus]);
+
+  // Refresh function
+  const refresh = useCallback(async () => {
+    if (!isAuthenticated || !user) {
+      return;
+    }
+    const abortController = new AbortController();
+    try {
+      await fetchPremiumStatus(abortController.signal);
+    } finally {
+      abortController.abort();
+    }
+  }, [isAuthenticated, user, fetchPremiumStatus]);
+
+  // Use base useUserTier hook for tier logic
+  const useUserTierParams: UseUserTierParams = {
+    isGuest: isGuest || !isAuthenticated,
+    userId: user?.uid || null,
+    isPremium,
+    isLoading,
+    error,
+  };
+
+  const tierInfo = useUserTier(useUserTierParams);
+
+  return {
+    ...tierInfo,
+    refresh,
+  };
+}
+

package/src/utils/__tests__/authUtils.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Authentication Utilities Tests
+ * 
+ * Tests for authentication check functions
+ */
+
+import {
+  isAuthenticated,
+  isGuest,
+} from '../authUtils';
+
+describe('isAuthenticated', () => {
+  it('should return false for guest users', () => {
+    expect(isAuthenticated(true, null)).toBe(false);
+    expect(isAuthenticated(true, 'user123')).toBe(false);
+  });
+
+  it('should return false when userId is null', () => {
+    expect(isAuthenticated(false, null)).toBe(false);
+  });
+
+  it('should return true for authenticated users', () => {
+    expect(isAuthenticated(false, 'user123')).toBe(true);
+  });
+
+  it('should throw error for invalid inputs', () => {
+    expect(() => isAuthenticated('invalid' as any, null)).toThrow(TypeError);
+    expect(() => isAuthenticated(true, 123 as any)).toThrow(TypeError);
+    expect(() => isAuthenticated(true, '' as any)).toThrow(TypeError);
+  });
+});
+
+describe('isGuest', () => {
+  it('should return true for guest users', () => {
+    expect(isGuest(true, null)).toBe(true);
+    expect(isGuest(true, 'user123')).toBe(true);
+  });
+
+  it('should return true when userId is null', () => {
+    expect(isGuest(false, null)).toBe(true);
+  });
+
+  it('should return false for authenticated users', () => {
+    expect(isGuest(false, 'user123')).toBe(false);
+  });
+
+  it('should throw error for invalid inputs', () => {
+    expect(() => isGuest('invalid' as any, null)).toThrow(TypeError);
+    expect(() => isGuest(true, 123 as any)).toThrow(TypeError);
+    expect(() => isGuest(true, '' as any)).toThrow(TypeError);
+  });
+});

package/src/utils/__tests__/edgeCases.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Edge Cases Tests
+ * 
+ * Tests for edge cases and special scenarios
+ */
+
+import {
+  getUserTierInfo,
+} from '../tierUtils';
+import {
+  isAuthenticated,
+  isGuest,
+} from '../authUtils';
+import { validateUserId } from '../validation';
+
+describe('Edge Cases', () => {
+  describe('User ID validation', () => {
+    it('should handle empty string userId as invalid', () => {
+      expect(() => validateUserId('')).toThrow(TypeError);
+    });
+
+    it('should handle whitespace-only userId as invalid', () => {
+      expect(() => validateUserId('   ')).toThrow(TypeError);
+    });
+
+    it('should handle very long userId strings', () => {
+      const longUserId = 'a'.repeat(1000);
+      const result = getUserTierInfo(false, longUserId, true);
+      expect(result.userId).toBe(longUserId);
+      expect(result.tier).toBe('premium');
+    });
+
+    it('should handle special characters in userId', () => {
+      const specialUserId = 'user-123_test@example.com';
+      const result = getUserTierInfo(false, specialUserId, false);
+      expect(result.userId).toBe(specialUserId);
+      expect(result.tier).toBe('freemium');
+    });
+  });
+
+  describe('Authentication edge cases', () => {
+    it('should handle conflicting auth states consistently', () => {
+      // isGuest=true but userId provided - should prioritize guest logic
+      expect(isAuthenticated(true, 'user123')).toBe(false);
+      expect(isGuest(true, 'user123')).toBe(true);
+      
+      const result = getUserTierInfo(true, 'user123', true);
+      expect(result.tier).toBe('guest');
+      expect(result.isPremium).toBe(false);
+    });
+
+    it('should handle isGuest=false but null userId', () => {
+      // isGuest=false but userId=null - should treat as guest
+      expect(isAuthenticated(false, null)).toBe(false);
+      expect(isGuest(false, null)).toBe(true);
+      
+      const result = getUserTierInfo(false, null, true);
+      expect(result.tier).toBe('guest');
+      expect(result.isPremium).toBe(false);
+    });
+  });
+
+  describe('Premium status edge cases', () => {
+    it('should ignore isPremium for guest users regardless of value', () => {
+      const guestTrue = getUserTierInfo(true, null, true);
+      const guestFalse = getUserTierInfo(true, null, false);
+      
+      expect(guestTrue.isPremium).toBe(false);
+      expect(guestFalse.isPremium).toBe(false);
+      expect(guestTrue.tier).toBe('guest');
+      expect(guestFalse.tier).toBe('guest');
+    });
+
+    it('should handle authenticated users with various premium states', () => {
+      const premium = getUserTierInfo(false, 'user123', true);
+      const freemium = getUserTierInfo(false, 'user123', false);
+      
+      expect(premium.tier).toBe('premium');
+      expect(premium.isPremium).toBe(true);
+      expect(freemium.tier).toBe('freemium');
+      expect(freemium.isPremium).toBe(false);
+    });
+  });
+});

package/src/utils/__tests__/premiumUtils.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Premium Utilities Tests
+ * 
+ * Tests for premium status fetching and async functions
+ */
+
+import {
+  getIsPremium,
+} from '../premiumStatusUtils';
+import {
+  getUserTierInfoAsync,
+  checkPremiumAccessAsync,
+} from '../premiumAsyncUtils';
+import type { PremiumStatusFetcher } from '../types';
+
+describe('getIsPremium', () => {
+  describe('Sync mode (boolean isPremium)', () => {
+    it('should return false for guest users', () => {
+      const result = getIsPremium(true, null, true);
+      expect(result).toBe(false);
+    });
+
+    it('should return false when userId is null', () => {
+      const result = getIsPremium(false, null, true);
+      expect(result).toBe(false);
+    });
+
+    it('should return true when isPremium is true', () => {
+      const result = getIsPremium(false, 'user123', true);
+      expect(result).toBe(true);
+    });
+
+    it('should return false when isPremium is false', () => {
+      const result = getIsPremium(false, 'user123', false);
+      expect(result).toBe(false);
+    });
+
+    it('should throw error for invalid inputs', () => {
+      expect(() => getIsPremium('invalid' as any, null, true)).toThrow(TypeError);
+      expect(() => getIsPremium(true, 123 as any, true)).toThrow(TypeError);
+    });
+  });
+
+  describe('Async mode (fetcher)', () => {
+    const mockFetcher: PremiumStatusFetcher = {
+      isPremium: jest.fn(),
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should return false for guest users without calling fetcher', async () => {
+      const result = await getIsPremium(true, null, mockFetcher);
+      expect(result).toBe(false);
+      expect(mockFetcher.isPremium).not.toHaveBeenCalled();
+    });
+
+    it('should return false when userId is null without calling fetcher', async () => {
+      const result = await getIsPremium(false, null, mockFetcher);
+      expect(result).toBe(false);
+      expect(mockFetcher.isPremium).not.toHaveBeenCalled();
+    });
+
+    it('should call fetcher for authenticated users', async () => {
+      (mockFetcher.isPremium as jest.Mock).mockResolvedValue(true);
+      
+      const result = await getIsPremium(false, 'user123', mockFetcher);
+      expect(result).toBe(true);
+      expect(mockFetcher.isPremium).toHaveBeenCalledWith('user123');
+      expect(mockFetcher.isPremium).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return false when fetcher returns false', async () => {
+      (mockFetcher.isPremium as jest.Mock).mockResolvedValue(false);
+      
+      const result = await getIsPremium(false, 'user123', mockFetcher);
+      expect(result).toBe(false);
+      expect(mockFetcher.isPremium).toHaveBeenCalledWith('user123');
+    });
+
+    it('should throw error when fetcher throws Error', async () => {
+      const error = new Error('Database error');
+      (mockFetcher.isPremium as jest.Mock).mockRejectedValue(error);
+      
+      await expect(getIsPremium(false, 'user123', mockFetcher)).rejects.toThrow(
+        'Failed to fetch premium status: Database error'
+      );
+    });
+
+    it('should throw error when fetcher throws non-Error', async () => {
+      const error = 'String error';
+      (mockFetcher.isPremium as jest.Mock).mockRejectedValue(error);
+      
+      await expect(getIsPremium(false, 'user123', mockFetcher)).rejects.toThrow(
+        'Failed to fetch premium status: String error'
+      );
+    });
+
+    it('should throw error for invalid inputs', () => {
+      // Invalid isGuest/userId - validation happens before async check (sync)
+      expect(() => getIsPremium('invalid' as any, null, mockFetcher)).toThrow(TypeError);
+      expect(() => getIsPremium(true, 123 as any, mockFetcher)).toThrow(TypeError);
+      
+      // Invalid fetcher - validation happens in async mode but throws sync
+      // Use authenticated user (not guest) to reach fetcher validation
+      expect(() => getIsPremium(false, 'user123', null as any)).toThrow(TypeError);
+      expect(() => getIsPremium(false, 'user123', {} as any)).toThrow(TypeError);
+    });
+  });
+});
+
+describe('getUserTierInfoAsync', () => {
+  const mockFetcher: PremiumStatusFetcher = {
+    isPremium: jest.fn(),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return guest tier for guest users', async () => {
+    const result = await getUserTierInfoAsync(true, null, mockFetcher);
+    expect(result.tier).toBe('guest');
+    expect(result.isPremium).toBe(false);
+    expect(mockFetcher.isPremium).not.toHaveBeenCalled();
+  });
+
+  it('should return premium tier when fetcher returns true', async () => {
+    (mockFetcher.isPremium as jest.Mock).mockResolvedValue(true);
+    
+    const result = await getUserTierInfoAsync(false, 'user123', mockFetcher);
+    expect(result.tier).toBe('premium');
+    expect(result.isPremium).toBe(true);
+    expect(result.isGuest).toBe(false);
+    expect(result.isAuthenticated).toBe(true);
+  });
+
+  it('should return freemium tier when fetcher returns false', async () => {
+    (mockFetcher.isPremium as jest.Mock).mockResolvedValue(false);
+    
+    const result = await getUserTierInfoAsync(false, 'user123', mockFetcher);
+    expect(result.tier).toBe('freemium');
+    expect(result.isPremium).toBe(false);
+    expect(result.isGuest).toBe(false);
+    expect(result.isAuthenticated).toBe(true);
+  });
+});
+
+describe('checkPremiumAccessAsync', () => {
+  const mockFetcher: PremiumStatusFetcher = {
+    isPremium: jest.fn(),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return false for guest users', async () => {
+    const result = await checkPremiumAccessAsync(true, null, mockFetcher);
+    expect(result).toBe(false);
+    expect(mockFetcher.isPremium).not.toHaveBeenCalled();
+  });
+
+  it('should return true when fetcher returns true', async () => {
+    (mockFetcher.isPremium as jest.Mock).mockResolvedValue(true);
+    
+    const result = await checkPremiumAccessAsync(false, 'user123', mockFetcher);
+    expect(result).toBe(true);
+  });
+
+  it('should return false when fetcher returns false', async () => {
+    (mockFetcher.isPremium as jest.Mock).mockResolvedValue(false);
+    
+    const result = await checkPremiumAccessAsync(false, 'user123', mockFetcher);
+    expect(result).toBe(false);
+  });
+});

package/src/utils/__tests__/tierUtils.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Tier Utilities Tests
+ * 
+ * Tests for tier determination and comparison functions
+ */
+
+import {
+  getUserTierInfo,
+  checkPremiumAccess,
+} from '../tierUtils';
+import {
+  hasTierAccess,
+  isTierPremium,
+  isTierFreemium,
+  isTierGuest,
+} from '../userTierUtils';
+
+describe('getUserTierInfo', () => {
+  describe('Guest users', () => {
+    it('should return guest tier when isGuest is true', () => {
+      const result = getUserTierInfo(true, null, false);
+      expect(result.tier).toBe('guest');
+      expect(result.isPremium).toBe(false);
+      expect(result.isGuest).toBe(true);
+      expect(result.isAuthenticated).toBe(false);
+      expect(result.userId).toBe(null);
+    });
+
+    it('should return guest tier when userId is null', () => {
+      const result = getUserTierInfo(false, null, false);
+      expect(result.tier).toBe('guest');
+      expect(result.isPremium).toBe(false);
+      expect(result.isGuest).toBe(true);
+      expect(result.isAuthenticated).toBe(false);
+      expect(result.userId).toBe(null);
+    });
+
+    it('should ignore isPremium for guest users', () => {
+      const result = getUserTierInfo(true, null, true);
+      expect(result.tier).toBe('guest');
+      expect(result.isPremium).toBe(false); // Guest users NEVER have premium
+    });
+  });
+
+  describe('Authenticated users', () => {
+    it('should return premium tier for authenticated premium users', () => {
+      const result = getUserTierInfo(false, 'user123', true);
+      expect(result.tier).toBe('premium');
+      expect(result.isPremium).toBe(true);
+      expect(result.isGuest).toBe(false);
+      expect(result.isAuthenticated).toBe(true);
+      expect(result.userId).toBe('user123');
+    });
+
+    it('should return freemium tier for authenticated non-premium users', () => {
+      const result = getUserTierInfo(false, 'user123', false);
+      expect(result.tier).toBe('freemium');
+      expect(result.isPremium).toBe(false);
+      expect(result.isGuest).toBe(false);
+      expect(result.isAuthenticated).toBe(true);
+      expect(result.userId).toBe('user123');
+    });
+  });
+
+  it('should throw error for invalid inputs', () => {
+    expect(() => getUserTierInfo('invalid' as any, null, false)).toThrow(TypeError);
+    expect(() => getUserTierInfo(true, 123 as any, false)).toThrow(TypeError);
+    expect(() => getUserTierInfo(true, null, 'invalid' as any)).toThrow(TypeError);
+  });
+});
+
+describe('checkPremiumAccess', () => {
+  it('should return false for guest users', () => {
+    expect(checkPremiumAccess(true, null, true)).toBe(false);
+    expect(checkPremiumAccess(true, null, false)).toBe(false);
+  });
+
+  it('should return false when userId is null', () => {
+    expect(checkPremiumAccess(false, null, true)).toBe(false);
+  });
+
+  it('should return true for authenticated premium users', () => {
+    expect(checkPremiumAccess(false, 'user123', true)).toBe(true);
+  });
+
+  it('should return false for authenticated freemium users', () => {
+    expect(checkPremiumAccess(false, 'user123', false)).toBe(false);
+  });
+
+  it('should throw error for invalid inputs', () => {
+    expect(() => checkPremiumAccess('invalid' as any, null, true)).toThrow(TypeError);
+    expect(() => checkPremiumAccess(true, 123 as any, true)).toThrow(TypeError);
+    expect(() => checkPremiumAccess(true, null, 'invalid' as any)).toThrow(TypeError);
+  });
+});
+
+describe('hasTierAccess', () => {
+  it('should return true when tier1 has higher access', () => {
+    expect(hasTierAccess('premium', 'freemium')).toBe(true);
+    expect(hasTierAccess('premium', 'guest')).toBe(true);
+    expect(hasTierAccess('freemium', 'guest')).toBe(true);
+  });
+
+  it('should return true when tiers are equal', () => {
+    expect(hasTierAccess('premium', 'premium')).toBe(true);
+    expect(hasTierAccess('freemium', 'freemium')).toBe(true);
+    expect(hasTierAccess('guest', 'guest')).toBe(true);
+  });
+
+  it('should return false when tier1 has lower access', () => {
+    expect(hasTierAccess('freemium', 'premium')).toBe(false);
+    expect(hasTierAccess('guest', 'premium')).toBe(false);
+    expect(hasTierAccess('guest', 'freemium')).toBe(false);
+  });
+});
+
+describe('isTierPremium', () => {
+  it('should return true for premium tier', () => {
+    expect(isTierPremium('premium')).toBe(true);
+  });
+
+  it('should return false for non-premium tiers', () => {
+    expect(isTierPremium('freemium')).toBe(false);
+    expect(isTierPremium('guest')).toBe(false);
+  });
+});
+
+describe('isTierFreemium', () => {
+  it('should return true for freemium tier', () => {
+    expect(isTierFreemium('freemium')).toBe(true);
+  });
+
+  it('should return false for non-freemium tiers', () => {
+    expect(isTierFreemium('premium')).toBe(false);
+    expect(isTierFreemium('guest')).toBe(false);
+  });
+});
+
+describe('isTierGuest', () => {
+  it('should return true for guest tier', () => {
+    expect(isTierGuest('guest')).toBe(true);
+  });
+
+  it('should return false for non-guest tiers', () => {
+    expect(isTierGuest('premium')).toBe(false);
+    expect(isTierGuest('freemium')).toBe(false);
+  });
+});