@umituz/react-native-subscription 1.0.7 → 1.1.1

package/lib/utils/subscriptionConstants.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 declare const SUBSCRIPTION_PLAN_TYPES: {
+    readonly WEEKLY: "weekly";
+    readonly MONTHLY: "monthly";
+    readonly YEARLY: "yearly";
+    readonly UNKNOWN: "unknown";
+};
+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 declare const MIN_SUBSCRIPTION_DURATIONS_DAYS: {
+    readonly WEEKLY: 6;
+    readonly MONTHLY: 28;
+    readonly YEARLY: 360;
+    readonly UNKNOWN: 28;
+};
+/**
+ * Subscription period multipliers
+ * Days to add for each subscription type
+ */
+export declare const SUBSCRIPTION_PERIOD_DAYS: {
+    readonly WEEKLY: 7;
+};
+/**
+ * Date calculation constants
+ */
+export declare const DATE_CONSTANTS: {
+    readonly MILLISECONDS_PER_DAY: number;
+    readonly DEFAULT_LOCALE: "en-US";
+};
+/**
+ * Subscription period unit mappings
+ * Maps RevenueCat period units to our internal types
+ */
+export declare const SUBSCRIPTION_PERIOD_UNITS: {
+    readonly WEEK: "WEEK";
+    readonly MONTH: "MONTH";
+    readonly YEAR: "YEAR";
+};
+/**
+ * Product ID keywords for plan detection
+ */
+export declare const PRODUCT_ID_KEYWORDS: {
+    readonly WEEKLY: readonly ["weekly", "week"];
+    readonly MONTHLY: readonly ["monthly", "month"];
+    readonly YEARLY: readonly ["yearly", "year", "annual"];
+};
+//# sourceMappingURL=subscriptionConstants.d.ts.map

package/lib/utils/subscriptionConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptionConstants.d.ts","sourceRoot":"","sources":["../../src/utils/subscriptionConstants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;CAK1B,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAC9B,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,OAAO,uBAAuB,CAAC,CAAC;AAEzE;;;;GAIG;AACH,eAAO,MAAM,+BAA+B;;;;;CAKlC,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;CAE3B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;CAI5B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC"}

package/lib/utils/subscriptionConstants.js

@@ -0,0 +1,61 @@
+/**
+ * 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',
+};
+/**
+ * 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,
+};
+/**
+ * Subscription period multipliers
+ * Days to add for each subscription type
+ */
+export const SUBSCRIPTION_PERIOD_DAYS = {
+    WEEKLY: 7,
+};
+/**
+ * Date calculation constants
+ */
+export const DATE_CONSTANTS = {
+    MILLISECONDS_PER_DAY: 1000 * 60 * 60 * 24,
+    DEFAULT_LOCALE: 'en-US',
+};
+/**
+ * Subscription period unit mappings
+ * Maps RevenueCat period units to our internal types
+ */
+export const SUBSCRIPTION_PERIOD_UNITS = {
+    WEEK: 'WEEK',
+    MONTH: 'MONTH',
+    YEAR: 'YEAR',
+};
+/**
+ * Product ID keywords for plan detection
+ */
+export const PRODUCT_ID_KEYWORDS = {
+    WEEKLY: ['weekly', 'week'],
+    MONTHLY: ['monthly', 'month'],
+    YEARLY: ['yearly', 'year', 'annual'],
+};
+//# sourceMappingURL=subscriptionConstants.js.map

package/lib/utils/subscriptionConstants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptionConstants.js","sourceRoot":"","sources":["../../src/utils/subscriptionConstants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;CACV,CAAC;AAKX;;;;GAIG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG;IAC7C,MAAM,EAAE,CAAC;IACT,OAAO,EAAE,EAAE;IACX,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,EAAE;CACH,CAAC;AAEX;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,MAAM,EAAE,CAAC;CACD,CAAC;AAEX;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,oBAAoB,EAAE,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;IACzC,cAAc,EAAE,OAAO;CACf,CAAC;AAEX;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;CACJ,CAAC;AAEX;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC;IAC7B,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC;CAC5B,CAAC"}

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "1.0.7",
+  "version": "1.1.1",
   "description": "Subscription management system for React Native apps - Database-first approach with secure validation",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "scripts": {
+    "build": "tsc",
     "typecheck": "tsc --noEmit",
     "lint": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "prepublishOnly": "npm run build",
     "version:patch": "npm version patch -m 'chore: release v%s'",
     "version:minor": "npm version minor -m 'chore: release v%s'",
     "version:major": "npm version major -m 'chore: release v%s'"
@@ -37,16 +42,21 @@
     "react-native": ">=0.74.0"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.14",
     "@types/react": "^18.2.45",
     "@types/react-native": "^0.73.0",
+    "find-up": "^8.0.0",
+    "jest": "^29.7.0",
     "react": "^18.2.0",
     "react-native": "^0.74.0",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.3.3"
   },
   "publishConfig": {
     "access": "public"
   },
   "files": [
+    "lib",
     "src",
     "README.md",
     "LICENSE"

package/src/domain/entities/SubscriptionStatus.test.ts

@@ -0,0 +1,106 @@
+/**
+ * Tests for Subscription Status Entity
+ */
+
+import {
+  createDefaultSubscriptionStatus,
+  isSubscriptionValid,
+} from './SubscriptionStatus';
+
+describe('SubscriptionStatus', () => {
+  describe('createDefaultSubscriptionStatus', () => {
+    it('should create default subscription status', () => {
+      const status = createDefaultSubscriptionStatus();
+      
+      expect(status).toEqual({
+        isPremium: false,
+        expiresAt: null,
+        productId: null,
+        purchasedAt: null,
+        customerId: null,
+        syncedAt: null,
+      });
+    });
+  });
+
+  describe('isSubscriptionValid', () => {
+    it('should return false for null status', () => {
+      expect(isSubscriptionValid(null)).toBe(false);
+    });
+
+    it('should return false for non-premium status', () => {
+      const status = {
+        isPremium: false,
+        expiresAt: null,
+        productId: null,
+        purchasedAt: null,
+        customerId: null,
+        syncedAt: null,
+      };
+      
+      expect(isSubscriptionValid(status)).toBe(false);
+    });
+
+    it('should return true 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(isSubscriptionValid(status)).toBe(true);
+    });
+
+    it('should return true for active subscription', () => {
+      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(isSubscriptionValid(status)).toBe(true);
+    });
+
+    it('should return true for subscription expired within 24 hour buffer', () => {
+      const pastDate = new Date();
+      pastDate.setDate(pastDate.getDate() - 1);
+      pastDate.setHours(pastDate.getHours() + 1); // 23 hours ago
+      
+      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(isSubscriptionValid(status)).toBe(true);
+    });
+
+    it('should return false for expired subscription beyond buffer', () => {
+      const pastDate = new Date();
+      pastDate.setDate(pastDate.getDate() - 2);
+      
+      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(isSubscriptionValid(status)).toBe(false);
+    });
+  });
+});

package/src/index.ts

@@ -66,12 +66,19 @@ export type { UseSubscriptionResult } from './presentation/hooks/useSubscription
 
 // Date utilities
 export {
-  isSubscriptionExpired,
-  getDaysUntilExpiration,
   formatExpirationDate,
   calculateExpirationDate,
 } from './utils/dateUtils';
 
+export {
+  isSubscriptionExpired,
+  getDaysUntilExpiration,
+} from './utils/dateValidationUtils';
+
+export {
+  extractPlanFromProductId,
+} from './utils/planDetectionUtils';
+
 // Price utilities
 export { formatPrice } from './utils/priceUtils';
 

package/src/infrastructure/services/ActivationHandler.ts

@@ -26,6 +26,10 @@ export async function activateSubscription(
   expiresAt: string | null
 ): Promise<SubscriptionStatus> {
   try {
+    if (typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+      console.log("[Subscription] Activating subscription in handler", { userId, productId, expiresAt });
+    }
+    
     const updatedStatus = await config.repository.updateSubscriptionStatus(
       userId,
       {
@@ -53,6 +57,10 @@ export async function deactivateSubscription(
   userId: string
 ): Promise<SubscriptionStatus> {
   try {
+    if (typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+      console.log("[Subscription] Deactivating subscription in handler", { userId });
+    }
+    
     const updatedStatus = await config.repository.updateSubscriptionStatus(
       userId,
       {

package/src/infrastructure/services/SubscriptionService.ts

@@ -39,11 +39,17 @@ export class SubscriptionService implements ISubscriptionService {
     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();
       }
 
       const isValid = this.repository.isSubscriptionValid(status);
       if (!isValid && status.isPremium) {
+        if (typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+          console.log("[Subscription] Expired subscription found, deactivating");
+        }
         return await this.deactivateSubscription(userId);
       }
 
@@ -64,6 +70,9 @@ export class SubscriptionService implements ISubscriptionService {
     productId: string,
     expiresAt: string | null
   ): Promise<SubscriptionStatus> {
+    if (typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+      console.log("[Subscription] Activating subscription", { userId, productId, expiresAt });
+    }
     return activateSubscription(
       this.handlerConfig,
       userId,
@@ -73,6 +82,9 @@ export class SubscriptionService implements ISubscriptionService {
   }
 
   async deactivateSubscription(userId: string): Promise<SubscriptionStatus> {
+    if (typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
+      console.log("[Subscription] Deactivating subscription", { userId });
+    }
     return deactivateSubscription(this.handlerConfig, userId);
   }
 
@@ -130,7 +142,7 @@ export function initializeSubscriptionService(
 }
 
 export function getSubscriptionService(): SubscriptionService | null {
-  if (!subscriptionServiceInstance && typeof __DEV__ !== "undefined" && __DEV__) {
+  if (!subscriptionServiceInstance && typeof globalThis !== 'undefined' && (globalThis as any).__DEV__) {
     // eslint-disable-next-line no-console
     console.warn("[Subscription] Service not initialized");
   }

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