@umituz/react-native-subscription 2.27.88 → 2.27.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.88",
+  "version": "2.27.91",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/credits/presentation/useCredits.ts

@@ -15,6 +15,7 @@ import {
   getCreditsConfig,
   isCreditsRepositoryConfigured,
 } from "../infrastructure/CreditsRepositoryProvider";
+import { calculateCreditPercentage, canAffordCost } from "../utils/creditCalculations";
 
 export const creditsQueryKeys = {
   all: ["credits"] as const,
@@ -49,14 +50,8 @@ export const useCredits = (): UseCreditsResult => {
   const userId = useAuthStore(selectUserId);
   const isConfigured = isCreditsRepositoryConfigured();
   
-  // Safe config access to prevent crash during initialization
-  let config;
-  try {
-    config = isConfigured ? getCreditsConfig() : { creditLimit: 200 }; // Default fallback
-  } catch (e) {
-    config = { creditLimit: 200 };
-  }
-
+  // Only access config if configured to avoid throwing errors
+  const config = isConfigured ? getCreditsConfig() : null;
   const queryEnabled = !!userId && isConfigured;
 
   const { data, status, error, refetch } = useQuery({
@@ -71,24 +66,6 @@ export const useCredits = (): UseCreditsResult => {
         throw new Error(result.error?.message || "Failed to fetch credits");
       }
 
-      // If subscription is expired, immediately return 0 credits
-      // to prevent any window where expired user could deduct
-      if (result.data?.status === "expired") {
-        // Sync to Firestore in background
-        repository.syncExpiredStatus(userId).catch((syncError) => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.warn("[useCredits] Background sync failed:", syncError);
-          }
-        });
-
-        // Return expired data with 0 credits immediately
-        return {
-          ...result.data,
-          credits: 0,
-          isPremium: false,
-        };
-      }
-
       return result.data || null;
     },
     enabled: queryEnabled,
@@ -119,12 +96,13 @@ export const useCredits = (): UseCreditsResult => {
 
   const derivedValues = useMemo(() => {
     const has = (credits?.credits ?? 0) > 0;
-    const percent = credits ? Math.round((credits.credits / config.creditLimit) * 100) : 0;
+    const limit = config?.creditLimit ?? 0;
+    const percent = calculateCreditPercentage(credits?.credits, limit);
     return { hasCredits: has, creditsPercent: percent };
-  }, [credits, config.creditLimit]);
+  }, [credits, config?.creditLimit]);
 
   const canAfford = useCallback(
-    (cost: number): boolean => (credits?.credits ?? 0) >= cost,
+    (cost: number): boolean => canAffordCost(credits?.credits, cost),
     [credits]
   );
 

package/src/domains/credits/presentation/useDeductCredit.ts

@@ -8,6 +8,7 @@ import { useMutation, useQueryClient } from "@umituz/react-native-design-system"
 import type { UserCredits } from "../core/Credits";
 import { getCreditsRepository } from "../infrastructure/CreditsRepositoryProvider";
 import { creditsQueryKeys } from "./useCredits";
+import { calculateRemainingCredits } from "../utils/creditCalculations";
 
 import { timezoneService } from "@umituz/react-native-design-system";
 
@@ -42,14 +43,12 @@ export const useDeductCredit = ({
       await queryClient.cancelQueries({ queryKey: creditsQueryKeys.user(userId) });
       const previousCredits = queryClient.getQueryData<UserCredits>(creditsQueryKeys.user(userId));
 
-      // Improved optimistic update logic
       if (!previousCredits) {
         return { previousCredits: null, skippedOptimistic: true };
       }
 
-      // If credits are insufficient, show 0 but don't skip optimistic update
-      // This provides better UX by showing the user what will happen
-      const newCredits = Math.max(0, previousCredits.credits - cost);
+      // Calculate new credits using utility
+      const newCredits = calculateRemainingCredits(previousCredits.credits, cost);
 
       queryClient.setQueryData<UserCredits | null>(creditsQueryKeys.user(userId), (old) => {
         if (!old) return old;
@@ -67,10 +66,10 @@ export const useDeductCredit = ({
       };
     },
     onError: (_err, _cost, context) => {
-      // Restore previous credits on error
-      // Skip restoration if credits were insufficient (optimistic update showed 0, which is correct)
-      if (userId && context?.previousCredits && !context.skippedOptimistic && !context.wasInsufficient) {
-        queryClient.setQueryData(creditsQueryKeys.user(userId), context.previousCredits);
+      // Always restore previous credits on error to prevent UI desync
+      // Use optional chaining to be safe
+      if (userId && context?.previousCredits && !context.skippedOptimistic) {
+         queryClient.setQueryData(creditsQueryKeys.user(userId), context.previousCredits);
       }
     },
     onSuccess: () => {

package/src/domains/credits/utils/creditCalculations.ts

@@ -0,0 +1,33 @@
+/**
+ * Credit Calculation Utilities
+ * Centralized logic for credit mathematical operations
+ */
+
+export const calculateCreditPercentage = (
+  currentCredits: number | null | undefined,
+  creditLimit: number
+): number => {
+  if (currentCredits === null || currentCredits === undefined || creditLimit <= 0) {
+    return 0;
+  }
+  
+  const percent = Math.round((currentCredits / creditLimit) * 100);
+  return Math.min(Math.max(percent, 0), 100); // Clamp between 0-100
+};
+
+export const canAffordCost = (
+  currentCredits: number | null | undefined,
+  cost: number
+): boolean => {
+  if (currentCredits === null || currentCredits === undefined) {
+    return false;
+  }
+  return currentCredits >= cost;
+};
+
+export const calculateRemainingCredits = (
+  currentCredits: number,
+  cost: number
+): number => {
+  return Math.max(0, currentCredits - cost);
+};

package/src/presentation/hooks/README.md

@@ -103,7 +103,7 @@ All hooks follow consistent patterns:
 - **ALWAYS** handle loading and error states
 - **NEVER** trust client-side state for security
 - **MUST** implement error boundaries
-- **ALWAYS** test with various user states (guest, free, premium)
+- **ALWAYS** test with various user states (anonymous, free, premium)
 
 ## AI Agent Guidelines
 

package/src/presentation/hooks/usePremium.md

@@ -40,7 +40,7 @@ Hook for checking and managing premium subscription status.
 
 - **NEVER** use for security decisions (server-side validation required)
 - **NEVER** assume instant data availability (always check loading state)
-- **DO NOT** use for guest users without proper handling
+- **DO NOT** use for anonymous users without proper handling
 
 ### CRITICAL SAFETY
 
@@ -67,7 +67,7 @@ Hook for checking and managing premium subscription status.
 - [ ] Provide upgrade path for free users
 - [ ] Test with premium user
 - [ ] Test with free user
-- [ ] Test with guest user
+- [ ] Test with anonymous user
 - [ ] Test offline scenario
 
 ### Common Patterns

package/src/utils/index.ts

@@ -1,6 +1,4 @@
-export * from "./aiCreditHelpers";
-export * from "./authUtils";
-export * from "./creditChecker";
+
 export * from "./creditMapper";
 export * from "./packagePeriodUtils";
 export * from "./packageTypeDetector";

package/src/utils/packageTypeDetector.ts

@@ -16,8 +16,10 @@ export type SubscriptionPackageType = PackageType;
  * Credit packages use a different system and don't need type detection
  */
 export function isCreditPackage(identifier: string): boolean {
+  if (!identifier) return false;
   // Matches "credit" as a word or part of a common naming pattern
-  return /\bcredit\b|_credit_|-credit-/i.test(identifier) || identifier.toLowerCase().includes("credit");
+  // More strict to avoid false positives (e.g. "accredited")
+  return /(?:^|[._-])credit(?:$|[._-])/i.test(identifier);
 }
 
 /**
@@ -36,37 +38,25 @@ export function detectPackageType(productIdentifier: string): SubscriptionPackag
     return PACKAGE_TYPE.UNKNOWN;
   }
 
-  // Preview API mode (Expo Go testing)
-  if (normalized.includes("preview")) {
-    if (__DEV__) {
-      console.log("[PackageTypeDetector] Detected: PREVIEW (monthly)");
-    }
-    return PACKAGE_TYPE.MONTHLY;
-  }
-
   // Weekly detection: matches "weekly" or "week" as distinct parts of the ID
   if (/\bweekly?\b|_week_|-week-|\.week\./i.test(normalized)) {
-    if (__DEV__) {
-      console.log("[PackageTypeDetector] Detected: WEEKLY");
-    }
     return PACKAGE_TYPE.WEEKLY;
   }
 
   // Monthly detection: matches "monthly" or "month"
   if (/\bmonthly?\b|_month_|-month-|\.month\./i.test(normalized)) {
-    if (__DEV__) {
-      console.log("[PackageTypeDetector] Detected: MONTHLY");
-    }
     return PACKAGE_TYPE.MONTHLY;
   }
 
   // Yearly detection: matches "yearly", "year", or "annual"
   if (/\byearly?\b|_year_|-year-|\.year\.|annual/i.test(normalized)) {
-    if (__DEV__) {
-      console.log("[PackageTypeDetector] Detected: YEARLY");
-    }
     return PACKAGE_TYPE.YEARLY;
   }
+  
+  // Lifetime detection: matches "lifetime"
+  if (/\blifetime\b|_lifetime_|-lifetime-|\.lifetime\./i.test(normalized)) {
+      return PACKAGE_TYPE.LIFETIME;
+  }
 
   if (__DEV__) {
     console.warn("[PackageTypeDetector] Unknown package type for:", productIdentifier);

package/src/utils/premiumStatusUtils.ts

@@ -5,18 +5,18 @@
  */
 
 import type { PremiumStatusFetcher } from './types';
-import { isGuest } from './authUtils';
+
 
 /**
  * Get isPremium value with centralized logic
  */
 export function getIsPremium(
-  isGuestFlag: boolean,
+  isAnonymous: boolean,
   userId: string | null,
   isPremiumOrFetcher: boolean | PremiumStatusFetcher,
 ): Promise<boolean> {
-  // Guest users NEVER have premium
-  if (isGuest(isGuestFlag, userId)) return Promise.resolve(false);
+  // Anonymous users NEVER have premium
+  if (isAnonymous || userId === null) return Promise.resolve(false);
 
   // Sync mode: return the provided isPremium value
   if (typeof isPremiumOrFetcher === 'boolean') return Promise.resolve(isPremiumOrFetcher);

package/src/utils/tierUtils.ts

@@ -5,18 +5,18 @@
  */
 
 import type { UserTierInfo } from './types';
-import { isGuest } from './authUtils';
+
 
 export function getUserTierInfo(
-  isGuestFlag: boolean,
+  isAnonymous: boolean,
   userId: string | null,
   isPremium: boolean,
 ): UserTierInfo {
-  if (isGuest(isGuestFlag, userId)) {
+  if (isAnonymous || userId === null) {
     return {
-      tier: 'guest',
+      tier: 'anonymous',
       isPremium: false,
-      isGuest: true,
+      isAnonymous: true,
       isAuthenticated: false,
       userId: null,
     };
@@ -25,17 +25,17 @@ export function getUserTierInfo(
   return {
     tier: isPremium ? 'premium' : 'freemium',
     isPremium,
-    isGuest: false,
+    isAnonymous: false,
     isAuthenticated: true,
     userId,
   };
 }
 
 export function checkPremiumAccess(
-  isGuestFlag: boolean,
+  isAnonymous: boolean,
   userId: string | null,
   isPremium: boolean,
 ): boolean {
-  if (isGuest(isGuestFlag, userId)) return false;
+  if (isAnonymous || userId === null) return false;
   return isPremium;
 }

package/src/utils/types.ts

@@ -4,7 +4,7 @@
  * Type definitions for user tier system
  */
 
-export type UserTier = 'guest' | 'freemium' | 'premium';
+export type UserTier = 'anonymous' | 'freemium' | 'premium';
 
 export interface UserTierInfo {
   /** User tier classification */
@@ -13,13 +13,13 @@ export interface UserTierInfo {
   /** Whether user has premium access */
   isPremium: boolean;
 
-  /** Whether user is a guest (not authenticated) */
-  isGuest: boolean;
+  /** Whether user is anonymous (not authenticated) */
+  isAnonymous: boolean;
 
   /** Whether user is authenticated */
   isAuthenticated: boolean;
 
-  /** User ID (null for guests) */
+  /** User ID (null for anonymous users) */
   userId: string | null;
 }
 

package/src/utils/validation.ts

@@ -7,7 +7,7 @@
 import type { UserTier, UserTierInfo } from './types';
 
 export function isValidUserTier(value: unknown): value is UserTier {
-  return value === 'guest' || value === 'freemium' || value === 'premium';
+  return value === 'anonymous' || value === 'freemium' || value === 'premium';
 }
 
 export function isUserTierInfo(value: unknown): value is UserTierInfo {
@@ -16,7 +16,7 @@ export function isUserTierInfo(value: unknown): value is UserTierInfo {
   return (
     isValidUserTier(obj.tier) &&
     typeof obj.isPremium === 'boolean' &&
-    typeof obj.isGuest === 'boolean' &&
+    typeof obj.isAnonymous === 'boolean' &&
     typeof obj.isAuthenticated === 'boolean' &&
     (obj.userId === null || typeof obj.userId === 'string')
   );

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

@@ -1,37 +0,0 @@
-/**
- * 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);
-  });
-});
-
-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);
-  });
-});

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

@@ -1,79 +0,0 @@
-/**
- * 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

@@ -1,89 +0,0 @@
-/**
- * Premium Utilities Tests
- *
- * Tests for premium status fetching and async functions
- */
-
-import { getIsPremium } from '../premiumStatusUtils';
-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);
-    });
-  });
-
-  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'
-      );
-    });
-  });
-});

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

@@ -1,74 +0,0 @@
-/**
- * Tier Utilities Tests
- *
- * Tests for tier determination and comparison functions
- */
-
-import { getUserTierInfo, checkPremiumAccess } from '../tierUtils';
-
-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);
-    });
-  });
-
-  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');
-    });
-  });
-});
-
-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);
-  });
-});

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

@@ -1,105 +0,0 @@
-/**
- * User Tier Validation Tests
- *
- * Tests for validation functions and type guards
- */
-
-import {
-  isValidUserTier,
-  isUserTierInfo,
-  validateUserId,
-  validateIsGuest,
-  validateIsPremium,
-  validateFetcher,
-} from '../validation';
-import type { UserTierInfo, PremiumStatusFetcher } from '../types';
-
-describe('isValidUserTier', () => {
-  it('should return true for valid tiers', () => {
-    expect(isValidUserTier('guest')).toBe(true);
-    expect(isValidUserTier('freemium')).toBe(true);
-    expect(isValidUserTier('premium')).toBe(true);
-  });
-
-  it('should return false for invalid values', () => {
-    expect(isValidUserTier('invalid')).toBe(false);
-    expect(isValidUserTier('')).toBe(false);
-    expect(isValidUserTier(null)).toBe(false);
-    expect(isValidUserTier(undefined)).toBe(false);
-    expect(isValidUserTier(123)).toBe(false);
-    expect(isValidUserTier({})).toBe(false);
-  });
-});
-
-describe('isUserTierInfo', () => {
-  it('should return true for valid UserTierInfo', () => {
-    const validInfo: UserTierInfo = {
-      tier: 'premium',
-      isPremium: true,
-      isGuest: false,
-      isAuthenticated: true,
-      userId: 'user123',
-    };
-    expect(isUserTierInfo(validInfo)).toBe(true);
-  });
-
-  it('should return false for invalid objects', () => {
-    expect(isUserTierInfo(null)).toBe(false);
-    expect(isUserTierInfo(undefined)).toBe(false);
-    expect(isUserTierInfo('string')).toBe(false);
-    expect(isUserTierInfo({})).toBe(false);
-    expect(isUserTierInfo({ tier: 'invalid' })).toBe(false);
-    expect(isUserTierInfo({ tier: 'premium' })).toBe(false);
-  });
-});
-
-describe('validateUserId', () => {
-  it('should not throw for valid userId', () => {
-    expect(() => validateUserId('user123')).not.toThrow();
-    expect(() => validateUserId(null)).not.toThrow();
-  });
-
-  it('should throw for invalid userId', () => {
-    expect(() => validateUserId('')).toThrow(TypeError);
-    expect(() => validateUserId('   ')).toThrow(TypeError);
-  });
-});
-
-describe('validateIsGuest', () => {
-  it('should not throw for valid isGuest', () => {
-    expect(() => validateIsGuest(true)).not.toThrow();
-    expect(() => validateIsGuest(false)).not.toThrow();
-  });
-
-  it('should throw for invalid isGuest', () => {
-    expect(() => validateIsGuest('true' as unknown as boolean)).toThrow(TypeError);
-    expect(() => validateIsGuest(1 as unknown as boolean)).toThrow(TypeError);
-  });
-});
-
-describe('validateIsPremium', () => {
-  it('should not throw for valid isPremium', () => {
-    expect(() => validateIsPremium(true)).not.toThrow();
-    expect(() => validateIsPremium(false)).not.toThrow();
-  });
-
-  it('should throw for invalid isPremium', () => {
-    expect(() => validateIsPremium('true' as unknown as boolean)).toThrow(TypeError);
-    expect(() => validateIsPremium(1 as unknown as boolean)).toThrow(TypeError);
-  });
-});
-
-describe('validateFetcher', () => {
-  it('should not throw for valid fetcher', () => {
-    const validFetcher: PremiumStatusFetcher = {
-      isPremium: async () => true,
-    };
-    expect(() => validateFetcher(validFetcher)).not.toThrow();
-  });
-
-  it('should throw for invalid fetcher', () => {
-    expect(() => validateFetcher(null as unknown as PremiumStatusFetcher)).toThrow(TypeError);
-    expect(() => validateFetcher({} as unknown as PremiumStatusFetcher)).toThrow(TypeError);
-    expect(() => validateFetcher({ isPremium: 'not a function' } as unknown as PremiumStatusFetcher)).toThrow(TypeError);
-  });
-});

package/src/utils/aiCreditHelpers.ts

@@ -1,113 +0,0 @@
-/**
- * AI Credit Helpers
- *
- * Common patterns for AI generation apps to handle credits.
- * Provides ready-to-use functions for credit checking and deduction.
- *
- * Usage:
- *   import { createAICreditHelpers } from '@umituz/react-native-subscription';
- *
- *   const helpers = createAICreditHelpers({
- *     repository,
- *     imageGenerationTypes: ['future_image', 'santa_transform'],
- *     onCreditDeducted: (userId) => invalidateCache(userId)
- *   });
- */
-
-import type { CreditsRepository } from "../domains/credits/infrastructure/CreditsRepository";
-import { createCreditChecker } from "./creditChecker";
-
-export interface AICreditHelpersConfig {
-  /**
-   * Credits repository instance
-   */
-  repository: CreditsRepository;
-
-  /**
-   * Optional map of operation types to credit costs.
-   * If an operation isn't in this map, cost defaults to 1.
-   * @example { 'high_res_image': 5, 'text_summary': 1 }
-   */
-  operationCosts?: Record<string, number>;
-
-  /**
-   * Optional callback called after successful credit deduction.
-   * Use this to invalidate TanStack Query cache or trigger UI updates.
-   */
-  onCreditDeducted?: (userId: string, cost: number) => void;
-}
-
-export interface AICreditHelpers {
-  /**
-   * Check if user has credits for a specific generation type
-   * @param userId - User ID
-   * @param generationType - Type of generation
-   * @returns boolean indicating if credits are available
-   */
-  checkCreditsForGeneration: (
-    userId: string | undefined,
-    generationType: string
-  ) => Promise<boolean>;
-
-  /**
-   * Deduct credits after successful generation
-   * @param userId - User ID
-   * @param generationType - Type of generation that was performed
-   */
-  deductCreditsForGeneration: (
-    userId: string | undefined,
-    generationType: string
-  ) => Promise<void>;
-
-  /**
-   * Get cost for a generation type
-   * @param generationType - Type of generation
-   * @returns number of credits
-   */
-  getCost: (generationType: string) => number;
-}
-
-/**
- * Creates AI-specific credit helper functions
- */
-export function createAICreditHelpers(
-  config: AICreditHelpersConfig
-): AICreditHelpers {
-  const { repository, operationCosts = {}, onCreditDeducted } = config;
-
-  // Map generation type to cost
-  const getCost = (generationType: string): number => {
-    return operationCosts[generationType] ?? 1;
-  };
-
-  // Create credit checker
-  const checker = createCreditChecker({
-    repository,
-    onCreditDeducted,
-  });
-
-  // Check if credits are available for generation
-  const checkCreditsForGeneration = async (
-    userId: string | undefined,
-    generationType: string
-  ): Promise<boolean> => {
-    const cost = getCost(generationType);
-    const result = await checker.checkCreditsAvailable(userId, cost);
-    return result.success;
-  };
-
-  // Deduct credits after successful generation
-  const deductCreditsForGeneration = async (
-    userId: string | undefined,
-    generationType: string
-  ): Promise<void> => {
-    const cost = getCost(generationType);
-    await checker.deductCreditsAfterSuccess(userId, cost);
-  };
-
-  return {
-    checkCreditsForGeneration,
-    deductCreditsForGeneration,
-    getCost,
-  };
-}

package/src/utils/authUtils.ts

@@ -1,19 +0,0 @@
-/**
- * Authentication Utilities
- *
- * Centralized logic for authentication checks
- */
-
-export function isAuthenticated(
-  isGuest: boolean,
-  userId: string | null,
-): boolean {
-  return !isGuest && userId !== null;
-}
-
-export function isGuest(
-  isGuestFlag: boolean,
-  userId: string | null,
-): boolean {
-  return isGuestFlag || userId === null;
-}

package/src/utils/creditChecker.ts

@@ -1,82 +0,0 @@
-/**
- * Credit Checker Utility
- *
- * Validates credit availability before operations.
- * Generic - works with any generation type mapping.
- */
-
-import type { CreditsRepository } from "../domains/credits/infrastructure/CreditsRepository";
-
-export interface CreditCheckResult {
-  success: boolean;
-  error?: string;
-}
-
-export interface CreditCheckerConfig {
-  repository: CreditsRepository;
-  /**
-   * Optional callback called after successful credit deduction.
-   * Use this to invalidate TanStack Query cache or trigger UI updates.
-   * @param userId - The user whose credits were deducted
-   * @param cost - The amount of credits deducted
-   */
-  onCreditDeducted?: (userId: string, cost: number) => void;
-}
-
-export const createCreditChecker = (config: CreditCheckerConfig) => {
-  const { repository, onCreditDeducted } = config;
-
-  const checkCreditsAvailable = async (
-    userId: string | undefined,
-    cost: number = 1
-  ): Promise<CreditCheckResult> => {
-    if (!userId) {
-      return { success: false, error: "anonymous_user_blocked" };
-    }
-
-    const hasCreditsAvailable = await repository.hasCredits(userId, cost);
-
-    if (!hasCreditsAvailable) {
-      return {
-        success: false,
-        error: "credits_exhausted",
-      };
-    }
-
-    return { success: true };
-  };
-
-  const deductCreditsAfterSuccess = async (
-    userId: string | undefined,
-    cost: number = 1
-  ): Promise<void> => {
-    if (!userId) return;
-
-    const maxRetries = 3;
-    let lastError: Error | null = null;
-
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      const result = await repository.deductCredit(userId, cost);
-      if (result.success) {
-        // Notify subscribers that credits were deducted
-        onCreditDeducted?.(userId, cost);
-        return;
-      }
-      lastError = new Error(result.error?.message || "Deduction failed");
-      await new Promise<void>((r) => setTimeout(() => r(), 500 * (attempt + 1)));
-    }
-
-    if (lastError) {
-      throw lastError;
-    }
-  };
-
-
-  return {
-    checkCreditsAvailable,
-    deductCreditsAfterSuccess,
-  };
-};
-
-export type CreditChecker = ReturnType<typeof createCreditChecker>;
-