@umituz/react-native-subscription 2.15.3 → 2.15.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.15.3",
+  "version": "2.15.5",
   "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/presentation/hooks/useSubscriptionSettingsConfig.ts

@@ -16,6 +16,7 @@ import { useCreditsArray, getSubscriptionStatusType } from "./useSubscriptionSet
 import { getCreditsConfig } from "../../infrastructure/repositories/CreditsRepositoryProvider";
 import { detectPackageType } from "../../utils/packageTypeDetector";
 import { getCreditAllocation } from "../../utils/creditMapper";
+import { getExpirationDate } from "../../revenuecat/infrastructure/utils/ExpirationDateCalculator";
 import type {
   SubscriptionSettingsConfig,
   SubscriptionStatusType,
@@ -75,8 +76,11 @@ export const useSubscriptionSettingsConfig = (
   }, [premiumEntitlement?.productIdentifier, creditLimit]);
 
   // Get expiration date from RevenueCat entitlement (source of truth)
-  // premiumEntitlement.expirationDate is an ISO string from RevenueCat
-  const entitlementExpirationDate = premiumEntitlement?.expirationDate || null;
+  // Apply sandbox-to-production conversion for better testing UX
+  const entitlementExpirationDate = useMemo(() => {
+    if (!premiumEntitlement) return null;
+    return getExpirationDate(premiumEntitlement);
+  }, [premiumEntitlement]);
 
   // Prefer CustomerInfo expiration (real-time) over cached status
   const expiresAtIso = entitlementExpirationDate || (statusExpirationDate

package/src/revenuecat/infrastructure/config/SandboxDurationConfig.ts

@@ -0,0 +1,42 @@
+/**
+ * Sandbox Duration Configuration
+ * Apple Sandbox subscription durations vs Production durations
+ *
+ * @see https://developer.apple.com/documentation/storekit/in-app_purchase/testing_in-app_purchases_with_sandbox
+ */
+
+import type { SubscriptionPackageType } from '../../../utils/packageTypeDetector';
+
+/**
+ * Apple Sandbox subscription durations in minutes
+ */
+export const SANDBOX_DURATIONS: Record<SubscriptionPackageType, number> = {
+  weekly: 3,
+  monthly: 5,
+  yearly: 60,
+  unknown: 5,
+};
+
+/**
+ * Production subscription durations in days
+ */
+export const PRODUCTION_DURATIONS: Record<SubscriptionPackageType, number> = {
+  weekly: 7,
+  monthly: 30,
+  yearly: 365,
+  unknown: 30,
+};
+
+/**
+ * Get production duration in days for a package type
+ */
+export function getProductionDurationDays(packageType: SubscriptionPackageType): number {
+  return PRODUCTION_DURATIONS[packageType] ?? PRODUCTION_DURATIONS.unknown;
+}
+
+/**
+ * Get sandbox duration in minutes for a package type
+ */
+export function getSandboxDurationMinutes(packageType: SubscriptionPackageType): number {
+  return SANDBOX_DURATIONS[packageType] ?? SANDBOX_DURATIONS.unknown;
+}

package/src/revenuecat/infrastructure/utils/ExpirationDateCalculator.ts

@@ -1,78 +1,37 @@
 /**
  * Expiration Date Calculator
- * Handles RevenueCat expiration date extraction with edge case handling
+ * Main entry point for calculating subscription expiration dates
  */
 
 import type { RevenueCatEntitlement } from '../../domain/types/RevenueCatTypes';
-import { detectPackageType, type SubscriptionPackageType } from '../../../utils/packageTypeDetector';
+import {
+  shouldConvertSandbox,
+  convertToProductionExpiration,
+  adjustPastExpiration,
+} from './SandboxDurationConverter';
 
 /**
- * Add subscription period to a date
- */
-function addSubscriptionPeriod(date: Date, packageType: SubscriptionPackageType): Date {
-  const newDate = new Date(date);
-
-  switch (packageType) {
-    case 'weekly':
-      newDate.setDate(newDate.getDate() + 7);
-      break;
-    case 'monthly':
-      newDate.setDate(newDate.getDate() + 30);
-      break;
-    case 'yearly':
-      newDate.setDate(newDate.getDate() + 365);
-      break;
-    default:
-      // Unknown type, default to monthly
-      newDate.setDate(newDate.getDate() + 30);
-      break;
-  }
-
-  return newDate;
-}
-
-/**
- * Adjust expiration date if it equals current date
- *
- * RevenueCat sometimes returns expiration date equal to purchase date
- * immediately after purchase. This causes false "expired" status.
+ * Get adjusted expiration date from entitlement
  *
- * Solution: If expiration date is today or in the past, add the subscription
- * period (weekly/monthly/yearly) to prevent false expiration.
+ * Handles:
+ * 1. Sandbox mode: Converts to production-equivalent dates for better UX
+ * 2. Past expiration: Adds subscription period if expiration is in the past
  */
-function adjustExpirationDate(
-  expirationDate: string,
-  productIdentifier: string
-): string {
-  const expDate = new Date(expirationDate);
-  const now = new Date();
-
-  // If expiration is in the future, no adjustment needed
-  if (expDate > now) {
-    return expirationDate;
-  }
-
-  // If expiration is today or past, add subscription period
-  const packageType = detectPackageType(productIdentifier);
-  const adjustedDate = addSubscriptionPeriod(expDate, packageType);
-
-  return adjustedDate.toISOString();
-}
-
 export function getExpirationDate(
   entitlement: RevenueCatEntitlement | null
 ): string | null {
-  if (!entitlement) {
+  if (!entitlement?.expirationDate) {
     return null;
   }
 
-  if (!entitlement.expirationDate) {
-    return null;
+  const { expirationDate, productIdentifier, isSandbox, latestPurchaseDate } = entitlement;
+
+  if (shouldConvertSandbox(isSandbox)) {
+    return convertToProductionExpiration(latestPurchaseDate, productIdentifier);
   }
 
-  // Apply edge case fix for same-day expirations
-  return adjustExpirationDate(
-    entitlement.expirationDate,
-    entitlement.productIdentifier
-  );
+  const expDate = new Date(expirationDate);
+  const adjustedDate = adjustPastExpiration(expDate, productIdentifier);
+
+  return adjustedDate.toISOString();
 }

package/src/revenuecat/infrastructure/utils/SandboxDurationConverter.ts

@@ -0,0 +1,68 @@
+/**
+ * Sandbox Duration Converter
+ * Converts Apple Sandbox subscription durations to production-equivalent dates
+ */
+
+import { detectPackageType, type SubscriptionPackageType } from '../../../utils/packageTypeDetector';
+import { getProductionDurationDays } from '../config/SandboxDurationConfig';
+
+/**
+ * Add production period to a date based on package type
+ */
+export function addProductionPeriod(
+  date: Date,
+  packageType: SubscriptionPackageType
+): Date {
+  const newDate = new Date(date);
+  const daysToAdd = getProductionDurationDays(packageType);
+  newDate.setDate(newDate.getDate() + daysToAdd);
+  return newDate;
+}
+
+/**
+ * Check if sandbox conversion should be applied
+ * Only applies in DEV mode with sandbox flag
+ */
+export function shouldConvertSandbox(isSandbox: boolean): boolean {
+  return isSandbox && __DEV__;
+}
+
+/**
+ * Convert sandbox expiration to production-equivalent expiration
+ *
+ * In Apple Sandbox:
+ * - Weekly subscriptions expire in 3 minutes
+ * - Monthly subscriptions expire in 5 minutes
+ * - Yearly subscriptions expire in 1 hour
+ *
+ * For better testing UX, we calculate the production-equivalent expiration
+ * based on the purchase date + production duration.
+ */
+export function convertToProductionExpiration(
+  purchaseDate: string | null,
+  productIdentifier: string
+): string {
+  const basePurchaseDate = purchaseDate ? new Date(purchaseDate) : new Date();
+  const packageType = detectPackageType(productIdentifier);
+  const productionExpiration = addProductionPeriod(basePurchaseDate, packageType);
+
+  return productionExpiration.toISOString();
+}
+
+/**
+ * Adjust expiration date if it's in the past
+ * Adds subscription period to prevent false expiration
+ */
+export function adjustPastExpiration(
+  expirationDate: Date,
+  productIdentifier: string
+): Date {
+  const now = new Date();
+
+  if (expirationDate > now) {
+    return expirationDate;
+  }
+
+  const packageType = detectPackageType(productIdentifier);
+  return addProductionPeriod(expirationDate, packageType);
+}

package/src/domains/README.md.bak

@@ -1,274 +0,0 @@
-# Domains
-
-Specialized domain modules implementing specific business logic and features.
-
-## Location
-
-**Directory**: `src/domains/`
-
-**Type**: Domain Collection
-
-## Strategy
-
-### Domain-Driven Design
-
-This directory implements Domain-Driven Design (DDD) principles:
-
-1. **Wallet Domain**: Credit balance, transactions, and purchase flow
-2. **Paywall Domain**: Upgrade prompts, subscription management
-3. **Config Domain**: Feature flags, subscription configuration
-
-Each domain is self-contained with:
-- **Domain Layer**: Business logic, entities, value objects
-- **Infrastructure Layer**: External integrations, repositories
-- **Presentation Layer**: Domain-specific hooks and components
-
-### Architecture Pattern
-
-```
-┌─────────────────────────────────────┐
-│         Application Layer           │
-│    (Use Cases, Orchestration)       │
-└──────────────┬──────────────────────┘
-               │
-       ┌───────┴────────┐
-       │                │
-┌──────▼──────┐  ┌─────▼──────┐
-│ Wallet      │  │ Paywall    │
-│ Domain      │  │ Domain     │
-├─────────────┤  ├────────────┤
-│ Domain      │  │ Domain     │
-│ Infra       │  │ Infra      │
-│ Presentation│  │ Presentation│
-└──────┬──────┘  └─────┬──────┘
-       │                │
-       └────────┬───────┘
-                │
-       ┌────────▼──────────┐
-       │ Shared Infra      │
-       │ (Firebase, etc)   │
-       └───────────────────┘
-```
-
-## Domain Modules
-
-### Wallet Domain (`wallet/`)
-
-**Responsibility**: Credit balance and transaction management
-
-**Key Features**:
-- Credit balance tracking
-- Transaction history
-- Purchase initialization
-- Real-time updates
-
-**Documentation**: `wallet/README.md`
-
-### Paywall Domain (`paywall/`)
-
-**Responsibility**: Subscription upgrade flows and paywall UI
-
-**Key Features**:
-- Paywall display logic
-- Subscription management
-- Feature gating
-- Upgrade prompts
-
-**Documentation**: `paywall/README.md`
-
-### Config Domain (`config/`)
-
-**Responsibility**: Subscription configuration and feature flags
-
-**Key Features**:
-- Subscription tiers
-- Feature configuration
-- Pricing rules
-- Feature flags
-
-**Documentation**: `config/README.md`
-
-## Restrictions
-
-### REQUIRED
-
-- **Domain Isolation**: Domains MUST NOT directly depend on each other
-- **Interface Segregation**: Use well-defined interfaces between layers
-- **Dependency Inversion**: Depend on abstractions, not concretions
-- **Testability**: All domains MUST be testable in isolation
-
-### PROHIBITED
-
-- **NEVER** share domain logic between domains (use shared kernel if needed)
-- **NEVER** create circular dependencies between domains
-- **DO NOT** bypass domain layer from presentation
-- **NEVER** expose infrastructure details to other domains
-
-### CRITICAL SAFETY
-
-- **ALWAYS** validate invariants at domain boundaries
-- **ALWAYS** implement domain errors for business rule violations
-- **NEVER** allow inconsistent domain state
-- **MUST** implement proper transaction boundaries
-- **ALWAYS** sanitize inputs from external sources
-
-## Rules
-
-### Domain Boundaries
-
-```typescript
-// CORRECT - Respecting domain boundaries
-// Wallet domain handles credits
-const { credits } = useCredits(); // From wallet domain
-
-// Paywall domain handles upgrades
-const { showPaywall } = usePaywallOperations(); // From paywall domain
-
-// INCORRECT - Crossing domain boundaries
-const walletRepository = new WalletRepository();
-// Directly using wallet repo in paywall component
-```
-
-### Domain Errors
-
-```typescript
-// CORRECT - Domain-specific errors
-class InsufficientCreditsError extends DomainError {
-  constructor(required: number, available: number) {
-    super(`Insufficient credits: need ${required}, have ${available}`);
-  }
-}
-
-// INCORRECT - Generic errors
-throw new Error('Not enough credits'); // Loses domain context
-```
-
-### Dependency Direction
-
-```typescript
-// CORRECT - Dependency inversion
-interface ICreditsRepository {
-  getBalance(userId: string): Promise<number>;
-  deductCredits(userId: string, amount: number): Promise<void>;
-}
-
-// Domain depends on interface, not implementation
-class CreditService {
-  constructor(private repo: ICreditsRepository) {}
-}
-
-// INCORRECT - Concrete dependency
-class CreditService {
-  constructor(private repo: FirebaseCreditsRepository) {}
-  // Tightly coupled to Firebase
-}
-```
-
-## AI Agent Guidelines
-
-### When Working with Domains
-
-1. **Always** respect domain boundaries
-2. **Always** use dependency inversion
-3. **Always** implement domain-specific errors
-4. **Always** validate invariants at boundaries
-5. **Never** create circular dependencies
-
-### Integration Checklist
-
-- [ ] Identify correct domain for feature
-- [ ] Respect domain boundaries
-- [ ] Use appropriate interfaces
-- [ ] Handle domain errors
-- [ ] Test domain in isolation
-- [ ] Document domain interactions
-- [ ] Validate invariants
-- [ ] Implement transaction boundaries
-- [ ] Test cross-domain scenarios
-- [ ] Verify no circular dependencies
-
-### Common Patterns
-
-1. **Aggregate Root**: Single entry point for aggregate
-2. **Value Objects**: Immutable values with no identity
-3. **Domain Events**: Publish domain events for side effects
-4. **Repositories**: Abstract data access
-5. **Factories**: Complex object creation
-6. **Domain Services**: Business logic that doesn't fit entities
-7. **Specification**: Business rule encapsulation
-8. **Anti-Corruption Layer**: Isolate from external systems
-
-## Related Documentation
-
-- **Wallet Domain**: `wallet/README.md`
-- **Paywall Domain**: `paywall/README.md`
-- **Config Domain**: `config/README.md`
-- **Domain Layer**: `../domain/README.md`
-- **Infrastructure**: `../infrastructure/README.md`
-
-## Domain Structure
-
-```
-src/domains/
-├── wallet/                # Wallet and credits domain
-│   ├── domain/           # Business logic
-│   ├── infrastructure/   # External integrations
-│   └── presentation/     # UI hooks and components
-├── paywall/              # Paywall and upgrades domain
-│   ├── domain/
-│   ├── infrastructure/
-│   └── presentation/
-└── config/               # Configuration domain
-    ├── domain/
-    ├── infrastructure/
-    └── presentation/
-```
-
-## Creating a New Domain
-
-When creating a new domain:
-
-1. **Define Boundaries**: What is the domain's responsibility?
-2. **Identify Entities**: What are the core business objects?
-3. **Define Invariants**: What rules must always be true?
-4. **Design Interfaces**: How will other layers interact?
-5. **Implement Repository**: Abstract data access
-6. **Create Presentation Layer**: Hooks and components
-7. **Write Tests**: Test domain logic in isolation
-8. **Document**: Provide comprehensive README
-
-Example:
-
-```typescript
-// Domain entity
-export class FeatureFlag {
-  constructor(
-    public readonly id: string,
-    public readonly name: string,
-    private _isEnabled: boolean
-  ) {}
-
-  get isEnabled(): boolean {
-    return this._isEnabled;
-  }
-
-  enable(): void {
-    this._isEnabled = true;
-  }
-
-  disable(): void {
-    this._isEnabled = false;
-  }
-}
-
-// Repository interface
-export interface IFeatureFlagRepository {
-  findById(id: string): Promise<FeatureFlag | null>;
-  save(flag: FeatureFlag): Promise<void>;
-}
-
-// Presentation hook
-export function useFeatureFlag(featureId: string) {
-  // Hook implementation
-}
-```