@umituz/react-native-subscription 1.0.6 → 1.1.0

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