@umituz/react-native-subscription 1.0.7 → 1.1.1

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();
-}
-
+}

package/src/utils/dateValidationUtils.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Tests for Date Validation Utilities
+ */
+
+import {
+  isSubscriptionExpired,
+  getDaysUntilExpiration,
+} from '../utils/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',
+      };
+      
+      const result = getDaysUntilExpiration(status);
+      expect(result === 0 || result === -0).toBe(true);
+    });
+  });
+
+  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

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

package/src/utils/planDetectionUtils.test.ts

@@ -0,0 +1,47 @@
+/**
+ * Tests for Plan Detection Utilities
+ */
+
+import { extractPlanFromProductId } from '../utils/planDetectionUtils';
+import { SUBSCRIPTION_PLAN_TYPES } from '../utils/subscriptionConstants';
+
+describe('Plan Detection Utils', () => {
+  describe('extractPlanFromProductId', () => {
+    it('should return UNKNOWN for null/undefined/empty productId', () => {
+      expect(extractPlanFromProductId(null)).toBe(SUBSCRIPTION_PLAN_TYPES.UNKNOWN);
+      expect(extractPlanFromProductId(undefined)).toBe(SUBSCRIPTION_PLAN_TYPES.UNKNOWN);
+      expect(extractPlanFromProductId('')).toBe(SUBSCRIPTION_PLAN_TYPES.UNKNOWN);
+    });
+
+    it('should detect weekly plans', () => {
+      expect(extractPlanFromProductId('com.app.weekly')).toBe(SUBSCRIPTION_PLAN_TYPES.WEEKLY);
+      expect(extractPlanFromProductId('com.app.week')).toBe(SUBSCRIPTION_PLAN_TYPES.WEEKLY);
+      expect(extractPlanFromProductId('WEEKLY_PREMIUM')).toBe(SUBSCRIPTION_PLAN_TYPES.WEEKLY);
+    });
+
+    it('should detect monthly plans', () => {
+      expect(extractPlanFromProductId('com.app.monthly')).toBe(SUBSCRIPTION_PLAN_TYPES.MONTHLY);
+      expect(extractPlanFromProductId('com.app.month')).toBe(SUBSCRIPTION_PLAN_TYPES.MONTHLY);
+      expect(extractPlanFromProductId('MONTHLY_PREMIUM')).toBe(SUBSCRIPTION_PLAN_TYPES.MONTHLY);
+    });
+
+    it('should detect yearly plans', () => {
+      expect(extractPlanFromProductId('com.app.yearly')).toBe(SUBSCRIPTION_PLAN_TYPES.YEARLY);
+      expect(extractPlanFromProductId('com.app.year')).toBe(SUBSCRIPTION_PLAN_TYPES.YEARLY);
+      expect(extractPlanFromProductId('com.app.annual')).toBe(SUBSCRIPTION_PLAN_TYPES.YEARLY);
+      expect(extractPlanFromProductId('YEARLY_PREMIUM')).toBe(SUBSCRIPTION_PLAN_TYPES.YEARLY);
+    });
+
+    it('should be case insensitive', () => {
+      expect(extractPlanFromProductId('WEEKLY')).toBe(SUBSCRIPTION_PLAN_TYPES.WEEKLY);
+      expect(extractPlanFromProductId('Monthly')).toBe(SUBSCRIPTION_PLAN_TYPES.MONTHLY);
+      expect(extractPlanFromProductId('YEARLY')).toBe(SUBSCRIPTION_PLAN_TYPES.YEARLY);
+    });
+
+    it('should return UNKNOWN for unrecognized patterns', () => {
+      expect(extractPlanFromProductId('com.app.lifetime')).toBe(SUBSCRIPTION_PLAN_TYPES.UNKNOWN);
+      expect(extractPlanFromProductId('com.app.premium')).toBe(SUBSCRIPTION_PLAN_TYPES.UNKNOWN);
+      expect(extractPlanFromProductId('random_string')).toBe(SUBSCRIPTION_PLAN_TYPES.UNKNOWN);
+    });
+  });
+});

package/src/utils/planDetectionUtils.ts

@@ -0,0 +1,40 @@
+/**
+ * Plan Detection Utilities
+ * Utilities for detecting subscription plan types from product IDs
+ *
+ * Following SOLID, DRY, KISS principles:
+ * - Single Responsibility: Only plan detection logic
+ * - DRY: No code duplication
+ * - KISS: Simple, clear implementations
+ */
+
+import {
+  SUBSCRIPTION_PLAN_TYPES,
+  PRODUCT_ID_KEYWORDS,
+  type SubscriptionPlanType,
+} from './subscriptionConstants';
+
+/**
+ * Extract subscription plan type from product ID
+ * Example: "com.company.app.weekly" → "weekly"
+ * @internal
+ */
+export 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;
+}

package/src/utils/priceUtils.test.ts

@@ -0,0 +1,35 @@
+/**
+ * Tests for Price Utilities
+ */
+
+import { formatPrice } from '../utils/priceUtils';
+
+describe('Price Utils', () => {
+  describe('formatPrice', () => {
+    it('should format USD price', () => {
+      expect(formatPrice(9.99, 'USD')).toBe('$9.99');
+    });
+
+    it('should format EUR price', () => {
+      expect(formatPrice(19.99, 'EUR')).toMatch(/€19\.99/);
+    });
+
+    it('should format TRY price', () => {
+      const result = formatPrice(229.99, 'TRY');
+      expect(result).toBeTruthy();
+      expect(result).toContain('229.99');
+    });
+
+    it('should format whole numbers', () => {
+      expect(formatPrice(10, 'USD')).toBe('$10.00');
+    });
+
+    it('should handle zero price', () => {
+      expect(formatPrice(0, 'USD')).toBe('$0.00');
+    });
+
+    it('should format large numbers', () => {
+      expect(formatPrice(999.99, 'USD')).toBe('$999.99');
+    });
+  });
+});