@umituz/react-native-subscription 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Subscription management system for React Native apps - Database-first approach with secure validation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -68,5 +68,18 @@ export {
   isSubscriptionExpired,
   getDaysUntilExpiration,
   formatExpirationDate,
+  calculateExpirationDate,
+  formatPrice,
+  getPeriodText,
 } from './utils/subscriptionUtils';
 
+export {
+  SUBSCRIPTION_PLAN_TYPES,
+  MIN_SUBSCRIPTION_DURATIONS_DAYS,
+  SUBSCRIPTION_PERIOD_DAYS,
+  DATE_CONSTANTS,
+  SUBSCRIPTION_PERIOD_UNITS,
+  PRODUCT_ID_KEYWORDS,
+  type SubscriptionPlanType,
+} from './utils/subscriptionConstants';
+

package/src/utils/subscriptionConstants.ts

@@ -0,0 +1,70 @@
+/**
+ * Subscription Constants
+ * Centralized constants for subscription operations
+ *
+ * Following SOLID, DRY, KISS principles:
+ * - Single Responsibility: Only constants, no logic
+ * - DRY: All constants in one place
+ * - KISS: Simple, clear constant definitions
+ */
+
+/**
+ * Subscription plan types
+ */
+export const SUBSCRIPTION_PLAN_TYPES = {
+  WEEKLY: 'weekly',
+  MONTHLY: 'monthly',
+  YEARLY: 'yearly',
+  UNKNOWN: 'unknown',
+} as const;
+
+export type SubscriptionPlanType =
+  (typeof SUBSCRIPTION_PLAN_TYPES)[keyof typeof SUBSCRIPTION_PLAN_TYPES];
+
+/**
+ * Minimum expected subscription durations in days
+ * Used to detect sandbox accelerated timers
+ * Includes 1 day tolerance for clock skew
+ */
+export const MIN_SUBSCRIPTION_DURATIONS_DAYS = {
+  WEEKLY: 6,
+  MONTHLY: 28,
+  YEARLY: 360,
+  UNKNOWN: 28,
+} as const;
+
+/**
+ * Subscription period multipliers
+ * Days to add for each subscription type
+ */
+export const SUBSCRIPTION_PERIOD_DAYS = {
+  WEEKLY: 7,
+} as const;
+
+/**
+ * Date calculation constants
+ */
+export const DATE_CONSTANTS = {
+  MILLISECONDS_PER_DAY: 1000 * 60 * 60 * 24,
+  DEFAULT_LOCALE: 'en-US',
+} as const;
+
+/**
+ * Subscription period unit mappings
+ * Maps RevenueCat period units to our internal types
+ */
+export const SUBSCRIPTION_PERIOD_UNITS = {
+  WEEK: 'WEEK',
+  MONTH: 'MONTH',
+  YEAR: 'YEAR',
+} as const;
+
+/**
+ * Product ID keywords for plan detection
+ */
+export const PRODUCT_ID_KEYWORDS = {
+  WEEKLY: ['weekly', 'week'],
+  MONTHLY: ['monthly', 'month'],
+  YEARLY: ['yearly', 'year', 'annual'],
+} as const;
+

package/src/utils/subscriptionUtils.ts

@@ -1,9 +1,48 @@
 /**
  * Subscription Utilities
  * Helper functions for subscription operations
+ *
+ * Following SOLID, DRY, KISS principles:
+ * - Single Responsibility: Each function does ONE thing
+ * - DRY: No code duplication
+ * - KISS: Simple, clear implementations
  */
 
 import type { SubscriptionStatus } from '../domain/entities/SubscriptionStatus';
+import {
+  SUBSCRIPTION_PLAN_TYPES,
+  MIN_SUBSCRIPTION_DURATIONS_DAYS,
+  SUBSCRIPTION_PERIOD_DAYS,
+  DATE_CONSTANTS,
+  SUBSCRIPTION_PERIOD_UNITS,
+  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
@@ -38,7 +77,9 @@ export function getDaysUntilExpiration(
   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));
+  const diffDays = Math.ceil(
+    diffMs / DATE_CONSTANTS.MILLISECONDS_PER_DAY,
+  );
 
   return diffDays > 0 ? diffDays : 0;
 }
@@ -48,7 +89,7 @@ export function getDaysUntilExpiration(
  */
 export function formatExpirationDate(
   expiresAt: string | null,
-  locale: string = 'en-US',
+  locale: string = DATE_CONSTANTS.DEFAULT_LOCALE,
 ): string | null {
   if (!expiresAt) {
     return null;
@@ -66,3 +107,209 @@ export function formatExpirationDate(
   }
 }
 
+/**
+ * Calculate expiration date based on subscription plan
+ * 
+ * This function handles:
+ * - RevenueCat sandbox accelerated timers (detects and recalculates)
+ * - Production dates (trusts RevenueCat's date if valid)
+ * - Monthly subscriptions: Same day next month (e.g., Nov 10 → Dec 10)
+ * - 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 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)
+ * // Returns: '2024-12-10T...' (Dec 10, 2024)
+ * 
+ * @example
+ * // Yearly subscription purchased on Nov 10, 2024
+ * calculateExpirationDate('com.umituz.app.yearly', null)
+ * // Returns: '2025-11-10T...' (Nov 10, 2025)
+ */
+export function calculateExpirationDate(
+  productId: string | null | undefined,
+  revenueCatExpiresAt?: string | null,
+): string | null {
+  const plan = extractPlanFromProductId(productId);
+  const now = new Date();
+
+  // Check if RevenueCat's date is valid and not sandbox accelerated
+  if (revenueCatExpiresAt) {
+    try {
+      const rcDate = new Date(revenueCatExpiresAt);
+
+      // Only trust if date is in the future
+      if (rcDate > now) {
+        // Detect sandbox accelerated timers by checking duration
+        const durationMs = rcDate.getTime() - now.getTime();
+        const durationDays =
+          durationMs / DATE_CONSTANTS.MILLISECONDS_PER_DAY;
+
+        // Get minimum expected duration for this plan type
+        const minDurationMap: Record<SubscriptionPlanType, number> = {
+          [SUBSCRIPTION_PLAN_TYPES.WEEKLY]:
+            MIN_SUBSCRIPTION_DURATIONS_DAYS.WEEKLY,
+          [SUBSCRIPTION_PLAN_TYPES.MONTHLY]:
+            MIN_SUBSCRIPTION_DURATIONS_DAYS.MONTHLY,
+          [SUBSCRIPTION_PLAN_TYPES.YEARLY]:
+            MIN_SUBSCRIPTION_DURATIONS_DAYS.YEARLY,
+          [SUBSCRIPTION_PLAN_TYPES.UNKNOWN]:
+            MIN_SUBSCRIPTION_DURATIONS_DAYS.UNKNOWN,
+        };
+
+        const minDuration = minDurationMap[plan];
+
+        // If duration is reasonable, trust RevenueCat's date (production)
+        if (durationDays >= minDuration) {
+          return rcDate.toISOString();
+        }
+        // Otherwise, fall through to manual calculation (sandbox accelerated)
+      }
+    } catch {
+      // Invalid date, fall through to calculation
+    }
+  }
+
+  // Calculate production-equivalent expiration date
+  // Use current date as base to preserve the day of month/year
+  const calculatedDate = new Date(now);
+
+  switch (plan) {
+    case SUBSCRIPTION_PLAN_TYPES.WEEKLY:
+      // Weekly: +7 days
+      calculatedDate.setDate(
+        calculatedDate.getDate() + SUBSCRIPTION_PERIOD_DAYS.WEEKLY,
+      );
+      break;
+
+    case SUBSCRIPTION_PLAN_TYPES.MONTHLY:
+      // Monthly: Same day next month
+      // This handles edge cases like Jan 31 → Feb 28/29 correctly
+      calculatedDate.setMonth(calculatedDate.getMonth() + 1);
+      break;
+
+    case SUBSCRIPTION_PLAN_TYPES.YEARLY:
+      // Yearly: Same day next year
+      // This handles leap years correctly (Feb 29 → Feb 28/29)
+      calculatedDate.setFullYear(calculatedDate.getFullYear() + 1);
+      break;
+
+    default:
+      // Unknown plan type - default to 1 month
+      calculatedDate.setMonth(calculatedDate.getMonth() + 1);
+      break;
+  }
+
+  return calculatedDate.toISOString();
+}
+
+/**
+ * Format price for display
+ * Formats a price value with currency code using Intl.NumberFormat
+ *
+ * @param price - Price value (e.g., 9.99)
+ * @param currencyCode - ISO 4217 currency code (e.g., "USD", "EUR", "TRY")
+ * @returns Formatted price string (e.g., "$9.99", "€9.99", "₺9.99")
+ *
+ * @example
+ * formatPrice(9.99, "USD") // Returns: "$9.99"
+ * formatPrice(229.99, "TRY") // Returns: "₺229.99"
+ */
+export function formatPrice(price: number, currencyCode: string): string {
+  return new Intl.NumberFormat(DATE_CONSTANTS.DEFAULT_LOCALE, {
+    style: 'currency',
+    currency: currencyCode,
+  }).format(price);
+}
+
+/**
+ * Get subscription period text from RevenueCat package
+ * Extracts readable period text from PurchasesPackage or subscription period object
+ *
+ * @param input - RevenueCat PurchasesPackage or subscription period object
+ * @returns Human-readable period text (e.g., "month", "year", "2 months")
+ *
+ * @example
+ * // From PurchasesPackage
+ * getPeriodText(pkg) // Returns: "month"
+ *
+ * @example
+ * // From subscription period object
+ * getPeriodText({ unit: "MONTH", numberOfUnits: 1 }) // Returns: "month"
+ * getPeriodText({ unit: "YEAR", numberOfUnits: 1 }) // Returns: "year"
+ * getPeriodText({ unit: "MONTH", numberOfUnits: 3 }) // Returns: "3 months"
+ */
+export function getPeriodText(
+  input:
+    | {
+        product?: {
+          subscriptionPeriod?: {
+            unit: string;
+            numberOfUnits: number;
+          } | null;
+        };
+      }
+    | {
+        unit: string;
+        numberOfUnits: number;
+      }
+    | null
+    | undefined,
+): string {
+  if (!input) return '';
+
+  // Extract subscription period from PurchasesPackage or use directly
+  let subscriptionPeriod:
+    | {
+        unit: string;
+        numberOfUnits: number;
+      }
+    | null
+    | undefined;
+
+  // Check if input is PurchasesPackage (has product property)
+  if ('product' in input && input.product?.subscriptionPeriod) {
+    const period = input.product.subscriptionPeriod;
+    // Type guard: check if period is an object with unit and numberOfUnits
+    if (
+      typeof period === 'object' &&
+      'unit' in period &&
+      'numberOfUnits' in period
+    ) {
+      subscriptionPeriod = {
+        unit: period.unit as string,
+        numberOfUnits: period.numberOfUnits as number,
+      };
+    }
+  } else if ('unit' in input && 'numberOfUnits' in input) {
+    // Input is already a subscription period object
+    subscriptionPeriod = {
+      unit: input.unit,
+      numberOfUnits: input.numberOfUnits,
+    };
+  }
+
+  if (!subscriptionPeriod) return '';
+
+  const { unit, numberOfUnits } = subscriptionPeriod;
+
+  if (unit === SUBSCRIPTION_PERIOD_UNITS.MONTH) {
+    return numberOfUnits === 1 ? 'month' : `${numberOfUnits} months`;
+  }
+
+  if (unit === SUBSCRIPTION_PERIOD_UNITS.YEAR) {
+    return numberOfUnits === 1 ? 'year' : `${numberOfUnits} years`;
+  }
+
+  if (unit === SUBSCRIPTION_PERIOD_UNITS.WEEK) {
+    return numberOfUnits === 1 ? 'week' : `${numberOfUnits} weeks`;
+  }
+
+  return '';
+}
+