@umituz/react-native-subscription 2.14.90 → 2.14.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.14.90",
+  "version": "2.14.92",
   "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/domain/entities/SubscriptionStatus.test.ts

@@ -1,9 +1,7 @@
-/**
- * Tests for Subscription Status Entity
- */
-
+import {
   createDefaultSubscriptionStatus,
   isSubscriptionValid,
+  calculateDaysRemaining,
 } from './SubscriptionStatus';
 
 describe('SubscriptionStatus', () => {
@@ -18,6 +16,7 @@ describe('SubscriptionStatus', () => {
         purchasedAt: null,
         customerId: null,
         syncedAt: null,
+        status: 'none',
       });
     });
   });
@@ -69,10 +68,9 @@ describe('SubscriptionStatus', () => {
       expect(isSubscriptionValid(status)).toBe(true);
     });
 
-    it('should return true for subscription expired within 24 hour buffer', () => {
+    it('should return false for expired subscription', () => {
       const pastDate = new Date();
       pastDate.setDate(pastDate.getDate() - 1);
-      pastDate.setHours(pastDate.getHours() + 1); // 23 hours ago
       
       const status = {
         isPremium: true,
@@ -83,23 +81,25 @@ describe('SubscriptionStatus', () => {
         syncedAt: '2024-01-01T00:00:00.000Z',
       };
       
-      expect(isSubscriptionValid(status)).toBe(true);
+      expect(isSubscriptionValid(status)).toBe(false);
+    });
+  });
+
+  describe('calculateDaysRemaining', () => {
+    it('should return null for null input', () => {
+      expect(calculateDaysRemaining(null)).toBeNull();
     });
 
-    it('should return false for expired subscription beyond buffer', () => {
+    it('should return positive days for future expiration', () => {
+      const futureDate = new Date();
+      futureDate.setDate(futureDate.getDate() + 5);
+      expect(calculateDaysRemaining(futureDate.toISOString())).toBe(5);
+    });
+
+    it('should return 0 for past expiration', () => {
       const pastDate = new Date();
-      pastDate.setDate(pastDate.getDate() - 2);
-      
-      const status = {
-        isPremium: true,
-        expiresAt: pastDate.toISOString(),
-        productId: 'monthly',
-        purchasedAt: '2024-01-01T00:00:00.000Z',
-        customerId: 'customer123',
-        syncedAt: '2024-01-01T00:00:00.000Z',
-      };
-      
-      expect(isSubscriptionValid(status)).toBe(false);
+      pastDate.setDate(pastDate.getDate() - 5);
+      expect(calculateDaysRemaining(pastDate.toISOString())).toBe(0);
     });
   });
 });

package/src/domain/entities/SubscriptionStatus.ts

@@ -33,13 +33,13 @@ export const createDefaultSubscriptionStatus = (): SubscriptionStatus => ({
 
 export const isSubscriptionValid = (status: SubscriptionStatus | null): boolean => {
     if (!status || !status.isPremium) return false;
-
     if (!status.expiresAt) return true; // Lifetime
+    return new Date(status.expiresAt).getTime() > Date.now();
+};
 
-    const expirationDate = new Date(status.expiresAt);
-    const now = new Date();
-
-    // Add 24-hour grace period buffer
-    const buffer = 24 * 60 * 60 * 1000;
-    return expirationDate.getTime() + buffer > now.getTime();
+export const calculateDaysRemaining = (expiresAt: string | null): number | null => {
+    if (!expiresAt) return null;
+    const diff = new Date(expiresAt).getTime() - Date.now();
+    return Math.max(0, Math.ceil(diff / (1000 * 60 * 60 * 24)));
 };
+

package/src/presentation/hooks/useSubscriptionDetails.ts

@@ -2,10 +2,11 @@ import { useMemo } from "react";
 import { 
   type SubscriptionStatus, 
   SUBSCRIPTION_STATUS, 
-  type SubscriptionStatusType 
+  type SubscriptionStatusType,
+  isSubscriptionValid,
+  calculateDaysRemaining
 } from "../../domain/entities/SubscriptionStatus";
-import { isSubscriptionExpired } from "../../utils/dateValidationUtils";
-import { formatDateForLocale, calculateDaysRemaining } from "../utils/subscriptionDateUtils";
+import { formatDateForLocale } from "../utils/subscriptionDateUtils";
 
 export interface SubscriptionDetails {
   /** Raw subscription status */
@@ -53,10 +54,11 @@ export function useSubscriptionDetails(
       };
     }
 
-    const isExpired = isSubscriptionExpired(status);
+    const isValid = isSubscriptionValid(status);
+    const isExpired = status.isPremium && !isValid;
     const isLifetime = status.isPremium && !status.expiresAt;
     const daysRemainingValue = calculateDaysRemaining(status.expiresAt ?? null);
-    const isPremium = status.isPremium && !isExpired;
+    const isPremium = status.isPremium && isValid;
 
     let statusKey: SubscriptionStatusType = status.status || SUBSCRIPTION_STATUS.NONE;
     

package/src/presentation/hooks/useSubscriptionSettingsConfig.ts

@@ -9,12 +9,9 @@ import { useCredits } from "./useCredits";
 import { useSubscriptionStatus } from "./useSubscriptionStatus";
 import { useCustomerInfo } from "../../revenuecat/presentation/hooks/useCustomerInfo";
 import { usePaywallVisibility } from "./usePaywallVisibility";
+import { calculateDaysRemaining } from "../../domain/entities/SubscriptionStatus";
 import { SubscriptionManager } from "../../revenuecat/infrastructure/managers/SubscriptionManager";
-import {
-    convertPurchasedAt,
-    formatDateForLocale,
-    calculateDaysRemaining,
-} from "../utils/subscriptionDateUtils";
+import { formatDateForLocale, convertPurchasedAt } from "../utils/subscriptionDateUtils";
 import { useCreditsArray, getSubscriptionStatusType } from "./useSubscriptionSettingsConfig.utils";
 import type {
   SubscriptionSettingsConfig,
@@ -68,7 +65,7 @@ export const useSubscriptionSettingsConfig = (
   // Get expiration date from RevenueCat entitlement (source of truth)
   // premiumEntitlement.expirationDate is an ISO string from RevenueCat
   const entitlementExpirationDate = premiumEntitlement?.expirationDate || null;
-  
+
   // Prefer CustomerInfo expiration (real-time) over cached status
   const expiresAtIso = entitlementExpirationDate || (statusExpirationDate
     ? statusExpirationDate.toISOString()

package/src/presentation/utils/subscriptionDateUtils.ts

@@ -24,38 +24,18 @@ export const convertPurchasedAt = (purchasedAt: unknown): string | null => {
 };
 
 /**
- * Formats a date string for display
+ * Formats a date string to a simple DD.MM.YYYY format
  */
-export const formatDateForLocale = (
-  dateStr: string | null,
-  locale: string
-): string | null => {
+export const formatDate = (dateStr: string | null): string | null => {
   if (!dateStr) return null;
-
-  try {
-    return timezoneService.formatDate(new Date(dateStr), locale, {
-      year: "numeric",
-      month: "long",
-      day: "numeric",
-    });
-  } catch {
-    return null;
-  }
-};
-
-/**
- * Calculates days remaining until expiration
- */
-export const calculateDaysRemaining = (
-  expiresAtIso: string | null
-): number | null => {
-  if (!expiresAtIso) return null;
-
-  const expiresDate = new Date(expiresAtIso);
-  const now = new Date();
+  const date = new Date(dateStr);
+  if (isNaN(date.getTime())) return null;
   
-  // Use timezoneService's mathematical approach if possible, or keep existing log
-  const diff = expiresDate.getTime() - now.getTime();
-  return Math.max(0, Math.ceil(diff / (1000 * 60 * 60 * 24)));
+  const d = String(date.getDate()).padStart(2, '0');
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const y = date.getFullYear();
+  
+  return `${d}.${m}.${y}`;
 };
 
+

package/src/utils/authUtils.ts

@@ -4,62 +4,16 @@
  * Centralized logic for authentication checks
  */
 
-import { validateIsGuest, validateUserId } from './validation';
-
-/**
- * Check if user is authenticated
- * 
- * This is the SINGLE SOURCE OF TRUTH for authentication check.
- * All apps should use this function for consistent authentication logic.
- *
- * @param isGuest - Whether user is a guest
- * @param userId - User ID (null for guests)
- * @returns Whether user is authenticated
- * 
- * @example
- * ```typescript
- * // Guest user
- * isAuthenticated(true, null); // false
- * 
- * // Authenticated user
- * isAuthenticated(false, 'user123'); // true
- * ```
- */
 export function isAuthenticated(
   isGuest: boolean,
   userId: string | null,
 ): boolean {
-  validateIsGuest(isGuest);
-  validateUserId(userId);
-  
   return !isGuest && userId !== null;
 }
 
-/**
- * Check if user is guest
- * 
- * This is the SINGLE SOURCE OF TRUTH for guest check.
- * All apps should use this function for consistent guest logic.
- *
- * @param isGuest - Whether user is a guest
- * @param userId - User ID (null for guests)
- * @returns Whether user is a guest
- * 
- * @example
- * ```typescript
- * // Guest user
- * isGuest(true, null); // true
- * 
- * // Authenticated user
- * isGuest(false, 'user123'); // false
- * ```
- */
 export function isGuest(
   isGuestFlag: boolean,
   userId: string | null,
 ): boolean {
-  validateIsGuest(isGuestFlag);
-  validateUserId(userId);
-  
   return isGuestFlag || userId === null;
 }

package/src/utils/index.ts

@@ -2,7 +2,6 @@ export * from "./aiCreditHelpers";
 export * from "./authUtils";
 export * from "./creditChecker";
 export * from "./creditMapper";
-export * from "./dateValidationUtils";
 export * from "./packageFilter";
 export * from "./packagePeriodUtils";
 export * from "./packageTypeDetector";

package/src/utils/premiumStatusUtils.ts

@@ -4,58 +4,27 @@
  * Core premium status determination logic
  */
 
-import { validateIsGuest, validateUserId, validateFetcher } from './validation';
 import type { PremiumStatusFetcher } from './types';
 
 /**
  * Get isPremium value with centralized logic
- * 
- * This function handles the complete logic for determining premium status:
- * - Guest users NEVER have premium (returns false immediately)
- * - Authenticated users: uses provided isPremium value OR fetches using fetcher
- * 
- * This is the SINGLE SOURCE OF TRUTH for isPremium determination.
- * All apps should use this function instead of directly calling their premium service.
- * 
- * Two usage modes:
- * 1. Sync mode: If you already have isPremium value, pass it directly
- * 2. Async mode: If you need to fetch from database, pass a fetcher function
- *
- * @param isGuest - Whether user is a guest
- * @param userId - User ID (null for guests)
- * @param isPremiumOrFetcher - Either boolean (sync) or PremiumStatusFetcher (async)
- * @returns boolean (sync) or Promise<boolean> (async) - Whether user has premium subscription
  */
 export function getIsPremium(
   isGuestFlag: boolean,
   userId: string | null,
   isPremiumOrFetcher: boolean | PremiumStatusFetcher,
 ): boolean | Promise<boolean> {
-  validateIsGuest(isGuestFlag);
-  validateUserId(userId);
-
-  // Guest users NEVER have premium - this is centralized logic
-  if (isGuestFlag || userId === null) {
-    return false;
-  }
-
-  // Check if it's a boolean (sync mode) or fetcher (async mode)
-  if (typeof isPremiumOrFetcher === 'boolean') {
-    // Sync mode: return the provided isPremium value
-    return isPremiumOrFetcher;
-  }
+  // Guest users NEVER have premium
+  if (isGuestFlag || userId === null) return false;
 
-  // Async mode: validate fetcher and fetch premium status
-  validateFetcher(isPremiumOrFetcher);
+  // Sync mode: return the provided isPremium value
+  if (typeof isPremiumOrFetcher === 'boolean') return isPremiumOrFetcher;
 
-  // Authenticated users: fetch premium status using app's fetcher
-  // Package handles the logic, app handles the database operation
+  // Async mode: fetch premium status
   return (async () => {
     try {
       return await isPremiumOrFetcher.isPremium(userId);
     } catch (error) {
-      // If fetcher throws, assume not premium (fail-safe)
-      // Apps should handle errors in their fetcher implementation
       throw new Error(
         `Failed to fetch premium status: ${error instanceof Error ? error.message : String(error)}`
       );

package/src/utils/tierUtils.ts

@@ -4,39 +4,13 @@
  * Core logic for determining user tier and premium status
  */
 
-import { validateIsGuest, validateUserId, validateIsPremium } from './validation';
 import type { UserTierInfo } from './types';
 
-/**
- * Determine user tier from auth state and premium status
- * 
- * This is the SINGLE SOURCE OF TRUTH for tier determination.
- * All apps should use this function for consistent tier logic.
- *
- * @param isGuest - Whether user is a guest
- * @param userId - User ID (null for guests)
- * @param isPremium - Whether user has active premium subscription
- * @returns User tier information
- * 
- * @example
- * ```typescript
- * const tierInfo = getUserTierInfo(false, 'user123', true);
- * // Returns: { tier: 'premium', isPremium: true, isGuest: false, isAuthenticated: true, userId: 'user123' }
- * 
- * const guestInfo = getUserTierInfo(true, null, false);
- * // Returns: { tier: 'guest', isPremium: false, isGuest: true, isAuthenticated: false, userId: null }
- * ```
- */
 export function getUserTierInfo(
   isGuestFlag: boolean,
   userId: string | null,
   isPremium: boolean,
 ): UserTierInfo {
-  validateIsGuest(isGuestFlag);
-  validateUserId(userId);
-  validateIsPremium(isPremium);
-
-  // Guest users are always freemium, never premium
   if (isGuestFlag || userId === null) {
     return {
       tier: 'guest',
@@ -47,7 +21,6 @@ export function getUserTierInfo(
     };
   }
 
-  // Authenticated users: premium or freemium
   return {
     tier: isPremium ? 'premium' : 'freemium',
     isPremium,
@@ -57,41 +30,11 @@ export function getUserTierInfo(
   };
 }
 
-/**
- * Check if user has premium access (synchronous version)
- * 
- * Guest users NEVER have premium access, regardless of isPremium value.
- *
- * @param isGuest - Whether user is a guest
- * @param userId - User ID (null for guests)
- * @param isPremium - Whether user has active premium subscription
- * @returns Whether user has premium access
- * 
- * @example
- * ```typescript
- * // Guest user - always false
- * checkPremiumAccess(true, null, true); // false
- * 
- * // Authenticated premium user
- * checkPremiumAccess(false, 'user123', true); // true
- * 
- * // Authenticated freemium user
- * checkPremiumAccess(false, 'user123', false); // false
- * ```
- */
 export function checkPremiumAccess(
   isGuestFlag: boolean,
   userId: string | null,
   isPremium: boolean,
 ): boolean {
-  validateIsGuest(isGuestFlag);
-  validateUserId(userId);
-  validateIsPremium(isPremium);
-
-  // Guest users never have premium access
-  if (isGuestFlag || userId === null) {
-    return false;
-  }
-
+  if (isGuestFlag || userId === null) return false;
   return isPremium;
 }

package/src/utils/validation.ts

@@ -6,43 +6,13 @@
 
 import type { UserTier, UserTierInfo } from './types';
 
-/**
- * Type guard to check if a value is a valid UserTier
- * 
- * @param value - Value to check
- * @returns Whether value is a valid UserTier
- * 
- * @example
- * ```typescript
- * if (isValidUserTier(someValue)) {
- *   // TypeScript knows someValue is UserTier
- * }
- * ```
- */
 export function isValidUserTier(value: unknown): value is UserTier {
   return value === 'guest' || value === 'freemium' || value === 'premium';
 }
 
-/**
- * Type guard to check if an object is a valid UserTierInfo
- * 
- * @param value - Value to check
- * @returns Whether value is a valid UserTierInfo
- * 
- * @example
- * ```typescript
- * if (isUserTierInfo(someValue)) {
- *   // TypeScript knows someValue is UserTierInfo
- * }
- * ```
- */
 export function isUserTierInfo(value: unknown): value is UserTierInfo {
-  if (typeof value !== 'object' || value === null) {
-    return false;
-  }
-
+  if (typeof value !== 'object' || value === null) return false;
   const obj = value as Record<string, unknown>;
-
   return (
     isValidUserTier(obj.tier) &&
     typeof obj.isPremium === 'boolean' &&
@@ -50,70 +20,4 @@ export function isUserTierInfo(value: unknown): value is UserTierInfo {
     typeof obj.isAuthenticated === 'boolean' &&
     (obj.userId === null || typeof obj.userId === 'string')
   );
-}
-
-/**
- * Validate userId parameter
- * 
- * @param userId - User ID to validate
- * @throws {TypeError} If userId is invalid
- */
-export function validateUserId(userId: string | null): void {
-  if (userId !== null && typeof userId !== 'string') {
-    throw new TypeError(
-      `Invalid userId: expected string or null, got ${typeof userId}`
-    );
-  }
-
-  if (userId !== null && userId.trim() === '') {
-    throw new TypeError('Invalid userId: cannot be empty string');
-  }
-}
-
-/**
- * Validate isGuest parameter
- * 
- * @param isGuest - isGuest flag to validate
- * @throws {TypeError} If isGuest is invalid
- */
-export function validateIsGuest(isGuest: boolean): void {
-  if (typeof isGuest !== 'boolean') {
-    throw new TypeError(
-      `Invalid isGuest: expected boolean, got ${typeof isGuest}`
-    );
-  }
-}
-
-/**
- * Validate isPremium parameter
- * 
- * @param isPremium - isPremium flag to validate
- * @throws {TypeError} If isPremium is invalid
- */
-export function validateIsPremium(isPremium: boolean): void {
-  if (typeof isPremium !== 'boolean') {
-    throw new TypeError(
-      `Invalid isPremium: expected boolean, got ${typeof isPremium}`
-    );
-  }
-}
-
-/**
- * Validate PremiumStatusFetcher
- * 
- * @param fetcher - Fetcher to validate
- * @throws {TypeError} If fetcher is invalid
- */
-export function validateFetcher(fetcher: import('./types').PremiumStatusFetcher): void {
-  if (typeof fetcher !== 'object' || fetcher === null) {
-    throw new TypeError(
-      `Invalid fetcher: expected object, got ${typeof fetcher}`
-    );
-  }
-
-  if (typeof fetcher.isPremium !== 'function') {
-    throw new TypeError(
-      'Invalid fetcher: isPremium must be a function'
-    );
-  }
 }

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

@@ -1,140 +0,0 @@
-/**
- * Tests for Date Validation Utilities
- */
-
-  isSubscriptionExpired,
-  getDaysUntilExpiration,
-} from '../dateValidationUtils';
-
-describe('Date Validation Utils', () => {
-  describe('isSubscriptionExpired', () => {
-    it('should return true for null status', () => {
-      expect(isSubscriptionExpired(null)).toBe(true);
-    });
-
-    it('should return true for non-premium status', () => {
-      const status = {
-        isPremium: false,
-        expiresAt: null,
-        productId: null,
-        purchasedAt: null,
-        customerId: null,
-        syncedAt: null,
-      };
-
-      expect(isSubscriptionExpired(status)).toBe(true);
-    });
-
-    it('should return false for lifetime subscription', () => {
-      const status = {
-        isPremium: true,
-        expiresAt: null,
-        productId: 'lifetime',
-        purchasedAt: '2024-01-01T00:00:00.000Z',
-        customerId: 'customer123',
-        syncedAt: '2024-01-01T00:00:00.000Z',
-      };
-
-      expect(isSubscriptionExpired(status)).toBe(false);
-    });
-
-    it('should return false for future expiration', () => {
-      const futureDate = new Date();
-      futureDate.setDate(futureDate.getDate() + 30);
-
-      const status = {
-        isPremium: true,
-        expiresAt: futureDate.toISOString(),
-        productId: 'monthly',
-        purchasedAt: '2024-01-01T00:00:00.000Z',
-        customerId: 'customer123',
-        syncedAt: '2024-01-01T00:00:00.000Z',
-      };
-
-      expect(isSubscriptionExpired(status)).toBe(false);
-    });
-
-    it('should return true for past expiration', () => {
-      const pastDate = new Date();
-      pastDate.setDate(pastDate.getDate() - 1);
-
-      const status = {
-        isPremium: true,
-        expiresAt: pastDate.toISOString(),
-        productId: 'monthly',
-        purchasedAt: '2024-01-01T00:00:00.000Z',
-        customerId: 'customer123',
-        syncedAt: '2024-01-01T00:00:00.000Z',
-      };
-
-      expect(getDaysUntilExpiration(status)).toBe(0);
-    });
-  });
-
-  describe('getDaysUntilExpiration', () => {
-    it('should return null for null status', () => {
-      expect(getDaysUntilExpiration(null)).toBeNull();
-    });
-
-    it('should return null for status without expiration', () => {
-      const status = {
-        isPremium: true,
-        expiresAt: null,
-        productId: 'lifetime',
-        purchasedAt: '2024-01-01T00:00:00.000Z',
-        customerId: 'customer123',
-        syncedAt: '2024-01-01T00:00:00.000Z',
-      };
-
-      expect(getDaysUntilExpiration(status)).toBeNull();
-    });
-
-    it('should return positive days for future expiration', () => {
-      const futureDate = new Date();
-      futureDate.setDate(futureDate.getDate() + 5);
-
-      const status = {
-        isPremium: true,
-        expiresAt: futureDate.toISOString(),
-        productId: 'monthly',
-        purchasedAt: '2024-01-01T00:00:00.000Z',
-        customerId: 'customer123',
-        syncedAt: '2024-01-01T00:00:00.000Z',
-      };
-
-      expect(getDaysUntilExpiration(status)).toBe(5);
-    });
-
-    it('should return 0 for past expiration', () => {
-      const pastDate = new Date();
-      pastDate.setDate(pastDate.getDate() - 5);
-
-      const status = {
-        isPremium: true,
-        expiresAt: pastDate.toISOString(),
-        productId: 'monthly',
-        purchasedAt: '2024-01-01T00:00:00.000Z',
-        customerId: 'customer123',
-        syncedAt: '2024-01-01T00:00:00.000Z',
-      };
-
-      expect(getDaysUntilExpiration(status)).toBe(0);
-    });
-
-    it('should return 0 for today expiration', () => {
-      const today = new Date();
-      today.setHours(0, 0, 0, 0); // Start of today
-
-      const status = {
-        isPremium: true,
-        expiresAt: today.toISOString(),
-        productId: 'monthly',
-        purchasedAt: '2024-01-01T00:00:00.000Z',
-        customerId: 'customer123',
-        syncedAt: '2024-01-01T00:00:00.000Z',
-      };
-
-      expect(getDaysUntilExpiration(status)).toBe(0);
-    });
-  });
-});

package/src/utils/dateValidationUtils.ts

@@ -1,53 +0,0 @@
-/**
- * Date Validation Utilities
- * Utilities for validating and checking subscription dates
- *
- * Following SOLID, DRY, KISS principles:
- * - Single Responsibility: Only date validation logic
- * - DRY: No code duplication
- * - KISS: Simple, clear implementations
- */
-
-import type { SubscriptionStatus } from '../domain/entities/SubscriptionStatus';
-
-/**
- * Check if subscription is expired
- */
-export function isSubscriptionExpired(
-  status: SubscriptionStatus | null,
-): boolean {
-  if (!status || !status.isPremium) {
-    return true;
-  }
-
-  if (!status.expiresAt) {
-    // Lifetime subscription (no expiration)
-    return false;
-  }
-
-  const expirationDate = new Date(status.expiresAt);
-  const now = new Date();
-
-  return expirationDate.getTime() <= now.getTime();
-}
-
-/**
- * Get days until subscription expires
- * Returns null for lifetime subscriptions
- */
-export function getDaysUntilExpiration(
-  status: SubscriptionStatus | null,
-): number | null {
-  if (!status || !status.expiresAt) {
-    return null;
-  }
-
-  const expirationDate = new Date(status.expiresAt);
-  const now = new Date();
-  const diffMs = expirationDate.getTime() - now.getTime();
-  const diffDays = Math.ceil(
-    diffMs / (1000 * 60 * 60 * 24),
-  );
-
-  return Math.max(0, diffDays);
-}