@umituz/react-native-subscription 1.0.6 → 1.1.0

package/src/infrastructure/services/SubscriptionService.ts

@@ -1,183 +1,98 @@
 /**
  * Subscription Service Implementation
- * Secure subscription management with database-first approach
- *
- * SECURITY: Database-first approach ensures:
- * - 10-50x faster subscription checks
- * - Works offline (database cache)
- * - More reliable than SDK-dependent checks
- * - Server-side validation always enforced
+ * Database-first subscription management
  */
 
-import type { ISubscriptionService } from '../../application/ports/ISubscriptionService';
-import type { ISubscriptionRepository } from '../../application/ports/ISubscriptionRepository';
-import type { SubscriptionStatus } from '../../domain/entities/SubscriptionStatus';
-import {
-  createDefaultSubscriptionStatus,
-  isSubscriptionValid,
-} from '../../domain/entities/SubscriptionStatus';
+import type { ISubscriptionService } from "../../application/ports/ISubscriptionService";
+import type { ISubscriptionRepository } from "../../application/ports/ISubscriptionRepository";
+import type { SubscriptionStatus } from "../../domain/entities/SubscriptionStatus";
+import { createDefaultSubscriptionStatus } from "../../domain/entities/SubscriptionStatus";
 import {
   SubscriptionRepositoryError,
   SubscriptionValidationError,
-} from '../../domain/errors/SubscriptionError';
-import type { SubscriptionConfig } from '../../domain/value-objects/SubscriptionConfig';
+} from "../../domain/errors/SubscriptionError";
+import type { SubscriptionConfig } from "../../domain/value-objects/SubscriptionConfig";
+import {
+  activateSubscription,
+  deactivateSubscription,
+  type ActivationHandlerConfig,
+} from "./ActivationHandler";
 
 export class SubscriptionService implements ISubscriptionService {
   private repository: ISubscriptionRepository;
-  private onStatusChanged?: (
-    userId: string,
-    status: SubscriptionStatus,
-  ) => Promise<void> | void;
-  private onError?: (error: Error, context: string) => Promise<void> | void;
+  private handlerConfig: ActivationHandlerConfig;
 
   constructor(config: SubscriptionConfig) {
     if (!config.repository) {
-      throw new SubscriptionValidationError(
-        'Repository is required for SubscriptionService',
-      );
+      throw new SubscriptionValidationError("Repository is required");
     }
 
     this.repository = config.repository;
-    this.onStatusChanged = config.onStatusChanged;
-    this.onError = config.onError;
+    this.handlerConfig = {
+      repository: config.repository,
+      onStatusChanged: config.onStatusChanged,
+      onError: config.onError,
+    };
   }
 
-  /**
-   * Get subscription status for a user
-   * Returns default (free) status if user not found
-   */
   async getSubscriptionStatus(userId: string): Promise<SubscriptionStatus> {
     try {
       const status = await this.repository.getSubscriptionStatus(userId);
       if (!status) {
+        if (typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+          console.log("[Subscription] No status found for user, returning default");
+        }
         return createDefaultSubscriptionStatus();
       }
 
-      // Validate subscription status (check expiration)
       const isValid = this.repository.isSubscriptionValid(status);
       if (!isValid && status.isPremium) {
-        // Subscription expired, update status
-        const updatedStatus = await this.deactivateSubscription(userId);
-        return updatedStatus;
+        if (typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+          console.log("[Subscription] Expired subscription found, deactivating");
+        }
+        return await this.deactivateSubscription(userId);
       }
 
       return status;
     } catch (error) {
-      await this.handleError(
-        error instanceof Error
-          ? error
-          : new Error('Error getting subscription status'),
-        'SubscriptionService.getSubscriptionStatus',
-      );
+      await this.handleError(error, "getSubscriptionStatus");
       return createDefaultSubscriptionStatus();
     }
   }
 
-  /**
-   * Check if user has active subscription
-   */
   async isPremium(userId: string): Promise<boolean> {
     const status = await this.getSubscriptionStatus(userId);
     return this.repository.isSubscriptionValid(status);
   }
 
-  /**
-   * Activate subscription
-   */
   async activateSubscription(
     userId: string,
     productId: string,
-    expiresAt: string | null,
+    expiresAt: string | null
   ): Promise<SubscriptionStatus> {
-    try {
-      const updatedStatus = await this.repository.updateSubscriptionStatus(
-        userId,
-        {
-          isPremium: true,
-          productId,
-          expiresAt,
-          purchasedAt: new Date().toISOString(),
-          syncedAt: new Date().toISOString(),
-        },
-      );
-
-      // Call callback if provided
-      if (this.onStatusChanged) {
-        try {
-          await this.onStatusChanged(userId, updatedStatus);
-        } catch (error) {
-          // Don't fail activation if callback fails
-          await this.handleError(
-            error instanceof Error ? error : new Error('Callback failed'),
-            'SubscriptionService.activateSubscription.onStatusChanged',
-          );
-        }
-      }
-
-      return updatedStatus;
-    } catch (error) {
-      await this.handleError(
-        error instanceof Error
-          ? error
-          : new Error('Error activating subscription'),
-        'SubscriptionService.activateSubscription',
-      );
-      throw new SubscriptionRepositoryError(
-        'Failed to activate subscription',
-      );
+    if (typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+      console.log("[Subscription] Activating subscription", { userId, productId, expiresAt });
     }
+    return activateSubscription(
+      this.handlerConfig,
+      userId,
+      productId,
+      expiresAt
+    );
   }
 
-  /**
-   * Deactivate subscription
-   */
   async deactivateSubscription(userId: string): Promise<SubscriptionStatus> {
-    try {
-      const updatedStatus = await this.repository.updateSubscriptionStatus(
-        userId,
-        {
-          isPremium: false,
-          expiresAt: null,
-          productId: null,
-        },
-      );
-
-      // Call callback if provided
-      if (this.onStatusChanged) {
-        try {
-          await this.onStatusChanged(userId, updatedStatus);
-        } catch (error) {
-          // Don't fail deactivation if callback fails
-          await this.handleError(
-            error instanceof Error ? error : new Error('Callback failed'),
-            'SubscriptionService.deactivateSubscription.onStatusChanged',
-          );
-        }
-      }
-
-      return updatedStatus;
-    } catch (error) {
-      await this.handleError(
-        error instanceof Error
-          ? error
-          : new Error('Error deactivating subscription'),
-        'SubscriptionService.deactivateSubscription',
-      );
-      throw new SubscriptionRepositoryError(
-        'Failed to deactivate subscription',
-      );
+    if (typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+      console.log("[Subscription] Deactivating subscription", { userId });
     }
+    return deactivateSubscription(this.handlerConfig, userId);
   }
 
-  /**
-   * Update subscription status
-   */
   async updateSubscriptionStatus(
     userId: string,
-    updates: Partial<SubscriptionStatus>,
+    updates: Partial<SubscriptionStatus>
   ): Promise<SubscriptionStatus> {
     try {
-      // Add syncedAt timestamp
       const updatesWithSync = {
         ...updates,
         syncedAt: new Date().toISOString(),
@@ -185,61 +100,40 @@ export class SubscriptionService implements ISubscriptionService {
 
       const updatedStatus = await this.repository.updateSubscriptionStatus(
         userId,
-        updatesWithSync,
+        updatesWithSync
       );
 
-      // Call callback if provided
-      if (this.onStatusChanged) {
+      if (this.handlerConfig.onStatusChanged) {
         try {
-          await this.onStatusChanged(userId, updatedStatus);
+          await this.handlerConfig.onStatusChanged(userId, updatedStatus);
         } catch (error) {
-          // Don't fail update if callback fails
-          await this.handleError(
-            error instanceof Error ? error : new Error('Callback failed'),
-            'SubscriptionService.updateSubscriptionStatus.onStatusChanged',
-          );
+          await this.handleError(error, "updateSubscriptionStatus.callback");
         }
       }
 
       return updatedStatus;
     } catch (error) {
-      await this.handleError(
-        error instanceof Error
-          ? error
-          : new Error('Error updating subscription status'),
-        'SubscriptionService.updateSubscriptionStatus',
-      );
-      throw new SubscriptionRepositoryError(
-        'Failed to update subscription status',
-      );
+      await this.handleError(error, "updateSubscriptionStatus");
+      throw new SubscriptionRepositoryError("Failed to update subscription");
     }
   }
 
-  /**
-   * Handle errors with optional callback
-   */
-  private async handleError(error: Error, context: string): Promise<void> {
-    if (this.onError) {
-      try {
-        await this.onError(error, context);
-      } catch {
-        // Ignore callback errors
-      }
+  private async handleError(error: unknown, context: string): Promise<void> {
+    if (!this.handlerConfig.onError) return;
+
+    try {
+      const err = error instanceof Error ? error : new Error("Unknown error");
+      await this.handlerConfig.onError(err, `SubscriptionService.${context}`);
+    } catch {
+      // Ignore callback errors
     }
   }
 }
 
-/**
- * Singleton instance
- * Apps should use initializeSubscriptionService() to set up with their config
- */
 let subscriptionServiceInstance: SubscriptionService | null = null;
 
-/**
- * Initialize Subscription service with configuration
- */
 export function initializeSubscriptionService(
-  config: SubscriptionConfig,
+  config: SubscriptionConfig
 ): SubscriptionService {
   if (!subscriptionServiceInstance) {
     subscriptionServiceInstance = new SubscriptionService(config);
@@ -247,27 +141,14 @@ export function initializeSubscriptionService(
   return subscriptionServiceInstance;
 }
 
-/**
- * Get Subscription service instance
- * Returns null if service is not initialized (graceful degradation)
- */
 export function getSubscriptionService(): SubscriptionService | null {
-  if (!subscriptionServiceInstance) {
-    /* eslint-disable-next-line no-console */
-    if (__DEV__) {
-      console.warn(
-        'Subscription service is not initialized. Call initializeSubscriptionService() first.',
-      );
-    }
-    return null;
+  if (!subscriptionServiceInstance && typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+    // eslint-disable-next-line no-console
+    console.warn("[Subscription] Service not initialized");
   }
   return subscriptionServiceInstance;
 }
 
-/**
- * Reset Subscription service (useful for testing)
- */
 export function resetSubscriptionService(): void {
   subscriptionServiceInstance = null;
 }
-

package/src/presentation/hooks/useSubscription.ts

@@ -3,7 +3,7 @@
  * React hook for subscription management
  */
 
-import { useState, useCallback, useEffect } from 'react';
+import { useState, useCallback } from 'react';
 import { getSubscriptionService } from '../../infrastructure/services/SubscriptionService';
 import type { SubscriptionStatus } from '../../domain/entities/SubscriptionStatus';
 
@@ -44,6 +44,11 @@ export function useSubscription(): UseSubscriptionResult {
   const [error, setError] = useState<string | null>(null);
 
   const loadStatus = useCallback(async (userId: string) => {
+    if (!userId) {
+      setError('User ID is required');
+      return;
+    }
+
     const service = getSubscriptionService();
     if (!service) {
       setError('Subscription service is not initialized');
@@ -66,6 +71,11 @@ export function useSubscription(): UseSubscriptionResult {
   }, []);
 
   const refreshStatus = useCallback(async (userId: string) => {
+    if (!userId) {
+      setError('User ID is required');
+      return;
+    }
+
     const service = getSubscriptionService();
     if (!service) {
       setError('Subscription service is not initialized');
@@ -89,6 +99,11 @@ export function useSubscription(): UseSubscriptionResult {
 
   const activateSubscription = useCallback(
     async (userId: string, productId: string, expiresAt: string | null) => {
+      if (!userId || !productId) {
+        setError('User ID and Product ID are required');
+        return;
+      }
+
       const service = getSubscriptionService();
       if (!service) {
         setError('Subscription service is not initialized');
@@ -118,6 +133,11 @@ export function useSubscription(): UseSubscriptionResult {
   );
 
   const deactivateSubscription = useCallback(async (userId: string) => {
+    if (!userId) {
+      setError('User ID is required');
+      return;
+    }
+
     const service = getSubscriptionService();
     if (!service) {
       setError('Subscription service is not initialized');
@@ -140,7 +160,7 @@ export function useSubscription(): UseSubscriptionResult {
     }
   }, []);
 
-  const isPremium = status ? status.isPremium && (status.expiresAt === null || new Date(status.expiresAt) > new Date()) : false;
+  const isPremium = status?.isPremium && (status.expiresAt === null || new Date(status.expiresAt).getTime() > Date.now()) || false;
 
   return {
     status,

package/src/utils/dateUtils.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Tests for Date Utilities
+ */
+
+import {
+  formatExpirationDate,
+  calculateExpirationDate,
+} from '../utils/dateUtils';
+import { SUBSCRIPTION_PLAN_TYPES } from '../utils/subscriptionConstants';
+
+describe('Date Utils', () => {
+  describe('formatExpirationDate', () => {
+    it('should return null for null expiration', () => {
+      expect(formatExpirationDate(null)).toBeNull();
+    });
+
+    it('should format date correctly', () => {
+      const date = '2024-12-25T00:00:00.000Z';
+      const formatted = formatExpirationDate(date);
+      
+      expect(formatted).toMatch(/December 25, 2024/);
+    });
+
+    it('should use custom locale', () => {
+      const date = '2024-12-25T00:00:00.000Z';
+      const formatted = formatExpirationDate(date, 'tr-TR');
+      
+      expect(formatted).toBeTruthy();
+      expect(typeof formatted).toBe('string');
+    });
+
+    it('should return null for invalid date', () => {
+      const formatted = formatExpirationDate('invalid-date');
+      expect(formatted).toBeNull();
+    });
+  });
+
+  describe('calculateExpirationDate', () => {
+    beforeEach(() => {
+      // Mock current date for consistent testing
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date('2024-01-15T00:00:00.000Z'));
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it('should return null for null productId', () => {
+      expect(calculateExpirationDate(null)).toBeNull();
+      expect(calculateExpirationDate('')).toBeNull();
+      expect(calculateExpirationDate(undefined)).toBeNull();
+    });
+
+    it('should calculate weekly expiration', () => {
+      const result = calculateExpirationDate('com.app.weekly');
+      const expectedDate = new Date('2024-01-22T00:00:00.000Z');
+      
+      expect(result).toBe(expectedDate.toISOString());
+    });
+
+    it('should calculate monthly expiration', () => {
+      const result = calculateExpirationDate('com.app.monthly');
+      const expectedDate = new Date('2024-02-15T00:00:00.000Z');
+      
+      expect(result).toBe(expectedDate.toISOString());
+    });
+
+    it('should calculate yearly expiration', () => {
+      const result = calculateExpirationDate('com.app.yearly');
+      const expectedDate = new Date('2025-01-15T00:00:00.000Z');
+      
+      expect(result).toBe(expectedDate.toISOString());
+    });
+
+    it('should default to monthly for unknown plan', () => {
+      const result = calculateExpirationDate('com.app.unknown');
+      const expectedDate = new Date('2024-02-15T00:00:00.000Z');
+      
+      expect(result).toBe(expectedDate.toISOString());
+    });
+
+    it('should trust valid RevenueCat date', () => {
+      const futureDate = new Date('2024-02-20T00:00:00.000Z');
+      const result = calculateExpirationDate('com.app.monthly', futureDate.toISOString());
+      
+      expect(result).toBe(futureDate.toISOString());
+    });
+
+    it('should ignore RevenueCat date if too short (sandbox)', () => {
+      const nearFutureDate = new Date('2024-01-16T00:00:00.000Z'); // Only 1 day
+      const result = calculateExpirationDate('com.app.monthly', nearFutureDate.toISOString());
+      
+      // Should calculate manually instead of using RevenueCat date
+      const expectedDate = new Date('2024-02-15T00:00:00.000Z');
+      expect(result).toBe(expectedDate.toISOString());
+    });
+
+    it('should ignore past RevenueCat date', () => {
+      const pastDate = new Date('2024-01-10T00:00:00.000Z');
+      const result = calculateExpirationDate('com.app.monthly', pastDate.toISOString());
+      
+      // Should calculate manually instead of using RevenueCat date
+      const expectedDate = new Date('2024-02-15T00:00:00.000Z');
+      expect(result).toBe(expectedDate.toISOString());
+    });
+
+    it('should handle invalid RevenueCat date', () => {
+      const result = calculateExpirationDate('com.app.monthly', 'invalid-date');
+      
+      // Should calculate manually instead of using RevenueCat date
+      const expectedDate = new Date('2024-02-15T00:00:00.000Z');
+      expect(result).toBe(expectedDate.toISOString());
+    });
+  });
+});

package/src/utils/dateUtils.ts

@@ -3,88 +3,20 @@
  * Subscription date-related helper functions
  *
  * Following SOLID, DRY, KISS principles:
- * - Single Responsibility: Only date-related operations
+ * - Single Responsibility: Only date formatting and calculation
  * - DRY: No code duplication
  * - KISS: Simple, clear implementations
  */
 
-import type { SubscriptionStatus } from '../domain/entities/SubscriptionStatus';
+import { DATE_CONSTANTS } from './subscriptionConstants';
+import { extractPlanFromProductId } from './planDetectionUtils';
 import {
   SUBSCRIPTION_PLAN_TYPES,
   MIN_SUBSCRIPTION_DURATIONS_DAYS,
   SUBSCRIPTION_PERIOD_DAYS,
-  DATE_CONSTANTS,
-  PRODUCT_ID_KEYWORDS,
   type SubscriptionPlanType,
 } from './subscriptionConstants';
 
-/**
- * Extract subscription plan type from product ID
- * Example: "com.umituz.app.weekly" → "weekly"
- * @internal
- */
-function extractPlanFromProductId(
-  productId: string | null | undefined,
-): SubscriptionPlanType {
-  if (!productId) return SUBSCRIPTION_PLAN_TYPES.UNKNOWN;
-
-  const lower = productId.toLowerCase();
-
-  if (PRODUCT_ID_KEYWORDS.WEEKLY.some((keyword) => lower.includes(keyword))) {
-    return SUBSCRIPTION_PLAN_TYPES.WEEKLY;
-  }
-  if (PRODUCT_ID_KEYWORDS.MONTHLY.some((keyword) => lower.includes(keyword))) {
-    return SUBSCRIPTION_PLAN_TYPES.MONTHLY;
-  }
-  if (PRODUCT_ID_KEYWORDS.YEARLY.some((keyword) => lower.includes(keyword))) {
-    return SUBSCRIPTION_PLAN_TYPES.YEARLY;
-  }
-
-  return SUBSCRIPTION_PLAN_TYPES.UNKNOWN;
-}
-
-/**
- * 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 / DATE_CONSTANTS.MILLISECONDS_PER_DAY,
-  );
-
-  return diffDays > 0 ? diffDays : 0;
-}
-
 /**
  * Format expiration date for display
  */
@@ -98,6 +30,9 @@ export function formatExpirationDate(
 
   try {
     const date = new Date(expiresAt);
+    if (isNaN(date.getTime())) {
+      return null;
+    }
     return date.toLocaleDateString(locale, {
       year: 'numeric',
       month: 'long',
@@ -118,24 +53,26 @@ export function formatExpirationDate(
  * - Yearly subscriptions: Same day next year (e.g., Nov 10, 2024 → Nov 10, 2025)
  * - Weekly subscriptions: +7 days
  *
- * @param productId - Product identifier (e.g., "com.umituz.app.monthly")
+ * @param productId - Product identifier (e.g., "com.company.app.monthly")
  * @param revenueCatExpiresAt - Optional expiration date from RevenueCat API
  * @returns ISO date string for expiration, or null if invalid
  *
  * @example
  * // Monthly subscription purchased on Nov 10, 2024
- * calculateExpirationDate('com.umituz.app.monthly', null)
+ * calculateExpirationDate('com.company.app.monthly', null)
  * // Returns: '2024-12-10T...' (Dec 10, 2024)
  *
  * @example
  * // Yearly subscription purchased on Nov 10, 2024
- * calculateExpirationDate('com.umituz.app.yearly', null)
+ * calculateExpirationDate('com.company.app.yearly', null)
  * // Returns: '2025-11-10T...' (Nov 10, 2025)
  */
 export function calculateExpirationDate(
   productId: string | null | undefined,
   revenueCatExpiresAt?: string | null,
 ): string | null {
+  if (!productId) return null;
+  
   const plan = extractPlanFromProductId(productId);
   const now = new Date();
 
@@ -207,5 +144,4 @@ export function calculateExpirationDate(
   }
 
   return calculatedDate.toISOString();
-}
-
+}