@umituz/react-native-subscription 2.27.39 → 2.27.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.39",
+  "version": "2.27.40",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domain/types/RevenueCatData.ts

@@ -0,0 +1,12 @@
+/**
+ * RevenueCat subscription data (Single Source of Truth)
+ * Used across the subscription package for storing RevenueCat data in Firestore
+ */
+export interface RevenueCatData {
+  expirationDate?: string | null;
+  willRenew?: boolean;
+  originalTransactionId?: string;
+  isPremium?: boolean;
+  /** RevenueCat period type: NORMAL, INTRO, or TRIAL */
+  periodType?: "NORMAL" | "INTRO" | "TRIAL";
+}

package/src/infrastructure/repositories/CreditsRepository.ts

@@ -1,7 +1,6 @@
 /**
  * Credits Repository
  */
-
 declare const __DEV__: boolean;
 
 import { doc, getDoc, runTransaction, serverTimestamp, type Firestore, type Transaction } from "firebase/firestore";
@@ -11,18 +10,11 @@ import type { UserCreditsDocumentRead, PurchaseSource } from "../models/UserCred
 import { initializeCreditsTransaction, type InitializeCreditsMetadata } from "../services/CreditsInitializer";
 import { detectPackageType } from "../../utils/packageTypeDetector";
 import { getCreditAllocation } from "../../utils/creditMapper";
-
 import { CreditsMapper } from "../mappers/CreditsMapper";
+import type { RevenueCatData } from "../../domain/types/RevenueCatData";
+import { initializeFreeCredits as initializeFreeCreditsService } from "../services/FreeCreditsService";
 
-/** RevenueCat subscription data to save (Single Source of Truth) */
-export interface RevenueCatData {
-  expirationDate?: string | null;
-  willRenew?: boolean;
-  originalTransactionId?: string;
-  isPremium?: boolean;
-  /** RevenueCat period type: NORMAL, INTRO, or TRIAL */
-  periodType?: "NORMAL" | "INTRO" | "TRIAL";
-}
+export type { RevenueCatData } from "../../domain/types/RevenueCatData";
 
 export class CreditsRepository extends BaseRepository {
   constructor(private config: CreditsConfig) { super(); }
@@ -58,11 +50,8 @@ export class CreditsRepository extends BaseRepository {
   }
 
   async initializeCredits(
-    userId: string,
-    purchaseId?: string,
-    productId?: string,
-    source?: PurchaseSource,
-    revenueCatData?: RevenueCatData
+    userId: string, purchaseId?: string, productId?: string,
+    source?: PurchaseSource, revenueCatData?: RevenueCatData
   ): Promise<CreditsResult> {
     const db = getFirestore();
     if (!db) return { success: false, error: { message: "No DB", code: "INIT_ERR" } };
@@ -79,9 +68,7 @@ export class CreditsRepository extends BaseRepository {
       }
 
       const metadata: InitializeCreditsMetadata = {
-        productId,
-        source,
-        // RevenueCat data for Single Source of Truth
+        productId, source,
         expirationDate: revenueCatData?.expirationDate,
         willRenew: revenueCatData?.willRenew,
         originalTransactionId: revenueCatData?.originalTransactionId,
@@ -89,23 +76,14 @@ export class CreditsRepository extends BaseRepository {
         periodType: revenueCatData?.periodType,
       };
 
-      const res = await initializeCreditsTransaction(
-        db,
-        this.getRef(db, userId),
-        cfg,
-        purchaseId,
-        metadata
-      );
-
+      const res = await initializeCreditsTransaction(db, this.getRef(db, userId), cfg, purchaseId, metadata);
       return {
         success: true,
-        data: CreditsMapper.toEntity({
-            ...res,
-            purchasedAt: undefined,
-            lastUpdatedAt: undefined,
-        })
+        data: CreditsMapper.toEntity({ ...res, purchasedAt: undefined, lastUpdatedAt: undefined })
       };
-    } catch (e: any) { return { success: false, error: { message: e.message, code: "INIT_ERR" } }; }
+    } catch (e: any) {
+      return { success: false, error: { message: e.message, code: "INIT_ERR" } };
+    }
   }
 
   async deductCredit(userId: string, cost: number = 1): Promise<DeductCreditsResult> {
@@ -133,98 +111,22 @@ export class CreditsRepository extends BaseRepository {
     return !!(res.success && res.data && res.data.credits >= cost);
   }
 
-  /**
-   * Initialize free credits for new users
-   * Creates a credits document with freeCredits amount (no subscription)
-   * Uses transaction to prevent race condition with premium init
-   */
   async initializeFreeCredits(userId: string): Promise<CreditsResult> {
-    const db = getFirestore();
-    if (!db) return { success: false, error: { message: "No DB", code: "INIT_ERR" } };
-
-    const freeCredits = this.config.freeCredits ?? 0;
-    if (freeCredits <= 0) {
-      return { success: false, error: { message: "Free credits not configured", code: "NO_FREE_CREDITS" } };
-    }
-
-    try {
-      const ref = this.getRef(db, userId);
-
-      // Use transaction to atomically check-and-set
-      const result = await runTransaction(db, async (tx: Transaction) => {
-        const snap = await tx.get(ref);
-
-        // Don't overwrite if document already exists (premium or previous init)
-        if (snap.exists()) {
-          if (__DEV__) console.log("[CreditsRepository] Credits document already exists, skipping free credits init");
-          const existing = snap.data() as UserCreditsDocumentRead;
-          return { skipped: true, data: CreditsMapper.toEntity(existing) };
-        }
-
-        // Create new document with free credits
-        const now = serverTimestamp();
-
-        const creditsData = {
-          // Not premium - just free credits
-          isPremium: false,
-          status: "free" as const,
-
-          // Free credits - store initial amount for tracking
-          credits: freeCredits,
-          creditLimit: freeCredits,
-          initialFreeCredits: freeCredits,
-          isFreeCredits: true,
-
-          // Dates
-          createdAt: now,
-          lastUpdatedAt: now,
-        };
-
-        tx.set(ref, creditsData);
-
-        if (__DEV__) console.log("[CreditsRepository] Initialized free credits:", { userId: userId.slice(0, 8), credits: freeCredits });
-
-        return {
-          skipped: false,
-          data: {
-            isPremium: false,
-            status: "free" as const,
-            credits: freeCredits,
-            creditLimit: freeCredits,
-            purchasedAt: null,
-            expirationDate: null,
-            lastUpdatedAt: null,
-            willRenew: false,
-          }
-        };
-      });
-
-      return { success: true, data: result.data };
-    } catch (e: any) {
-      if (__DEV__) console.error("[CreditsRepository] Free credits init error:", e.message);
-      return { success: false, error: { message: e.message, code: "INIT_ERR" } };
-    }
+    return initializeFreeCreditsService({ config: this.config, getRef: this.getRef.bind(this) }, userId);
   }
 
-  /** Sync expired subscription status to Firestore (background) */
   async syncExpiredStatus(userId: string): Promise<void> {
     const db = getFirestore();
     if (!db) return;
-
     try {
       const ref = this.getRef(db, userId);
       const { updateDoc } = await import("firebase/firestore");
-      await updateDoc(ref, {
-        isPremium: false,
-        status: "expired",
-        lastUpdatedAt: serverTimestamp(),
-      });
-      if (__DEV__) console.log("[CreditsRepository] Synced expired status for:", userId.slice(0, 8));
+      await updateDoc(ref, { isPremium: false, status: "expired", lastUpdatedAt: serverTimestamp() });
+      if (__DEV__) console.log("[CreditsRepository] Synced expired status:", userId.slice(0, 8));
     } catch (e) {
       if (__DEV__) console.error("[CreditsRepository] Sync expired failed:", e);
     }
   }
-
 }
 
 export const createCreditsRepository = (c: CreditsConfig) => new CreditsRepository(c);

package/src/infrastructure/services/FreeCreditsService.ts

@@ -0,0 +1,83 @@
+/**
+ * Free Credits Service
+ * Handles initialization of free credits for new users
+ */
+declare const __DEV__: boolean;
+
+import { runTransaction, serverTimestamp, type Firestore, type DocumentReference, type Transaction } from "firebase/firestore";
+import { getFirestore } from "@umituz/react-native-firebase";
+import type { CreditsConfig, CreditsResult, UserCredits } from "../../domain/entities/Credits";
+import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
+import { CreditsMapper } from "../mappers/CreditsMapper";
+
+export interface FreeCreditsServiceConfig {
+  config: CreditsConfig;
+  getRef: (db: Firestore, userId: string) => DocumentReference;
+}
+
+/**
+ * Initialize free credits for new users
+ * Creates a credits document with freeCredits amount (no subscription)
+ * Uses transaction to prevent race condition with premium init
+ */
+export async function initializeFreeCredits(
+  deps: FreeCreditsServiceConfig,
+  userId: string
+): Promise<CreditsResult> {
+  const db = getFirestore();
+  if (!db) return { success: false, error: { message: "No DB", code: "INIT_ERR" } };
+
+  const freeCredits = deps.config.freeCredits ?? 0;
+  if (freeCredits <= 0) {
+    return { success: false, error: { message: "Free credits not configured", code: "NO_FREE_CREDITS" } };
+  }
+
+  try {
+    const ref = deps.getRef(db, userId);
+
+    const result = await runTransaction(db, async (tx: Transaction) => {
+      const snap = await tx.get(ref);
+
+      // Don't overwrite if document already exists (premium or previous init)
+      if (snap.exists()) {
+        if (__DEV__) console.log("[FreeCreditsService] Credits document exists, skipping");
+        const existing = snap.data() as UserCreditsDocumentRead;
+        return { skipped: true, data: CreditsMapper.toEntity(existing) };
+      }
+
+      // Create new document with free credits
+      const now = serverTimestamp();
+      const creditsData = {
+        isPremium: false,
+        status: "free" as const,
+        credits: freeCredits,
+        creditLimit: freeCredits,
+        initialFreeCredits: freeCredits,
+        isFreeCredits: true,
+        createdAt: now,
+        lastUpdatedAt: now,
+      };
+
+      tx.set(ref, creditsData);
+
+      if (__DEV__) console.log("[FreeCreditsService] Initialized:", { userId: userId.slice(0, 8), credits: freeCredits });
+
+      const entity: UserCredits = {
+        isPremium: false,
+        status: "free",
+        credits: freeCredits,
+        creditLimit: freeCredits,
+        purchasedAt: null,
+        expirationDate: null,
+        lastUpdatedAt: null,
+        willRenew: false,
+      };
+      return { skipped: false, data: entity };
+    });
+
+    return { success: true, data: result.data };
+  } catch (e: any) {
+    if (__DEV__) console.error("[FreeCreditsService] Init error:", e.message);
+    return { success: false, error: { message: e.message, code: "INIT_ERR" } };
+  }
+}

package/src/infrastructure/services/SubscriptionInitializer.ts

@@ -1,38 +1,17 @@
 /**
  * Subscription Initializer
  */
-
 declare const __DEV__: boolean;
 
 import { Platform } from "react-native";
 import type { CustomerInfo } from "react-native-purchases";
-import type { CreditsConfig } from "../../domain/entities/Credits";
 import { configureCreditsRepository, getCreditsRepository } from "../repositories/CreditsRepositoryProvider";
 import { SubscriptionManager } from "../../revenuecat/infrastructure/managers/SubscriptionManager";
 import { configureAuthProvider } from "../../presentation/hooks/useAuthAwarePurchase";
-import type { RevenueCatData } from "../repositories/CreditsRepository";
-
-export interface FirebaseAuthLike {
-  currentUser: { uid: string; isAnonymous: boolean } | null;
-  onAuthStateChanged: (callback: (user: { uid: string; isAnonymous: boolean } | null) => void) => () => void;
-}
-
-export interface CreditPackageConfig { identifierPattern?: string; amounts?: Record<string, number>; }
-
-export interface SubscriptionInitConfig {
-  apiKey?: string;
-  apiKeyIos?: string;
-  apiKeyAndroid?: string;
-  entitlementId: string;
-  credits: CreditsConfig;
-  getAnonymousUserId: () => Promise<string>;
-  getFirebaseAuth: () => FirebaseAuthLike | null;
-  showAuthModal: () => void;
-  onCreditsUpdated?: (userId: string) => void;
-  creditPackages?: CreditPackageConfig;
-  timeoutMs?: number;
-  authStateTimeoutMs?: number;
-}
+import type { RevenueCatData } from "../../domain/types/RevenueCatData";
+import type { SubscriptionInitConfig, FirebaseAuthLike } from "./SubscriptionInitializerTypes";
+
+export type { FirebaseAuthLike, CreditPackageConfig, SubscriptionInitConfig } from "./SubscriptionInitializerTypes";
 
 const waitForAuthState = async (getAuth: () => FirebaseAuthLike | null, timeoutMs: number): Promise<string | undefined> => {
   const auth = getAuth();
@@ -44,6 +23,19 @@ const waitForAuthState = async (getAuth: () => FirebaseAuthLike | null, timeoutM
   });
 };
 
+/** Extract RevenueCat data from CustomerInfo (Single Source of Truth) */
+const extractRevenueCatData = (customerInfo: CustomerInfo, entitlementId: string): RevenueCatData => {
+  const entitlement = customerInfo.entitlements.active[entitlementId]
+    ?? customerInfo.entitlements.all[entitlementId];
+  return {
+    expirationDate: entitlement?.expirationDate ?? customerInfo.latestExpirationDate ?? null,
+    willRenew: entitlement?.willRenew ?? false,
+    originalTransactionId: entitlement?.originalPurchaseDate ?? undefined,
+    isPremium: Object.keys(customerInfo.entitlements.active).length > 0,
+    periodType: entitlement?.periodType as "NORMAL" | "INTRO" | "TRIAL" | undefined,
+  };
+};
+
 export const initializeSubscription = async (config: SubscriptionInitConfig): Promise<void> => {
   const {
     apiKey, apiKeyIos, apiKeyAndroid, entitlementId, credits,
@@ -56,148 +48,63 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
 
   configureCreditsRepository({ ...credits, creditPackageAmounts: creditPackages?.amounts });
 
-  /** Extract RevenueCat data from CustomerInfo (Single Source of Truth) */
-  const extractRevenueCatData = (customerInfo: CustomerInfo, _productId: string): RevenueCatData => {
-    const entitlement = customerInfo.entitlements.active[entitlementId]
-      ?? customerInfo.entitlements.all[entitlementId];
-
-    return {
-      expirationDate: entitlement?.expirationDate ?? customerInfo.latestExpirationDate ?? null,
-      willRenew: entitlement?.willRenew ?? false,
-      originalTransactionId: entitlement?.originalPurchaseDate ?? undefined,
-      isPremium: Object.keys(customerInfo.entitlements.active).length > 0,
-      periodType: entitlement?.periodType as "NORMAL" | "INTRO" | "TRIAL" | undefined,
-    };
-  };
-
   const onPurchase = async (userId: string, productId: string, customerInfo: CustomerInfo, source?: string) => {
-    if (__DEV__) {
-      console.log('[SubscriptionInitializer] onPurchase called:', { userId, productId, source });
-    }
+    if (__DEV__) console.log('[SubscriptionInitializer] onPurchase:', { userId, productId, source });
     try {
-      const revenueCatData = extractRevenueCatData(customerInfo, productId);
-      const result = await getCreditsRepository().initializeCredits(
-        userId,
-        `purchase_${productId}_${Date.now()}`,
-        productId,
-        source as any,
-        revenueCatData
-      );
-      if (__DEV__) {
-        console.log('[SubscriptionInitializer] Credits initialized:', result);
-      }
+      const revenueCatData = extractRevenueCatData(customerInfo, entitlementId);
+      await getCreditsRepository().initializeCredits(userId, `purchase_${productId}_${Date.now()}`, productId, source as any, revenueCatData);
       onCreditsUpdated?.(userId);
     } catch (error) {
-      if (__DEV__) {
-        console.error('[SubscriptionInitializer] Credits init failed:', error);
-      }
+      if (__DEV__) console.error('[SubscriptionInitializer] Credits init failed:', error);
     }
   };
 
   const onRenewal = async (userId: string, productId: string, newExpirationDate: string, customerInfo: CustomerInfo) => {
-    if (__DEV__) {
-      console.log('[SubscriptionInitializer] onRenewal called:', { userId, productId });
-    }
+    if (__DEV__) console.log('[SubscriptionInitializer] onRenewal:', { userId, productId });
     try {
-      const revenueCatData = extractRevenueCatData(customerInfo, productId);
-      // Update expiration date from renewal
+      const revenueCatData = extractRevenueCatData(customerInfo, entitlementId);
       revenueCatData.expirationDate = newExpirationDate || revenueCatData.expirationDate;
-      const result = await getCreditsRepository().initializeCredits(
-        userId,
-        `renewal_${productId}_${Date.now()}`,
-        productId,
-        "renewal" as any,
-        revenueCatData
-      );
-      if (__DEV__) {
-        console.log('[SubscriptionInitializer] Credits reset on renewal:', result);
-      }
+      await getCreditsRepository().initializeCredits(userId, `renewal_${productId}_${Date.now()}`, productId, "renewal" as any, revenueCatData);
       onCreditsUpdated?.(userId);
     } catch (error) {
-      if (__DEV__) {
-        console.error('[SubscriptionInitializer] Renewal credits init failed:', error);
-      }
+      if (__DEV__) console.error('[SubscriptionInitializer] Renewal credits init failed:', error);
     }
   };
 
-  /** Sync premium status changes (including cancellation) to Firestore */
   const onPremiumStatusChanged = async (
-    userId: string,
-    isPremium: boolean,
-    productId?: string,
-    expiresAt?: string,
-    willRenew?: boolean,
-    periodType?: "NORMAL" | "INTRO" | "TRIAL"
+    userId: string, isPremium: boolean, productId?: string,
+    expiresAt?: string, willRenew?: boolean, periodType?: "NORMAL" | "INTRO" | "TRIAL"
   ) => {
-    if (__DEV__) {
-      console.log('[SubscriptionInitializer] onPremiumStatusChanged:', { userId, isPremium, productId, willRenew, periodType });
-    }
+    if (__DEV__) console.log('[SubscriptionInitializer] onPremiumStatusChanged:', { userId, isPremium, productId, willRenew, periodType });
     try {
       // If not premium and no productId, this is a free user - don't overwrite free credits
       if (!isPremium && !productId) {
-        if (__DEV__) {
-          console.log('[SubscriptionInitializer] Free user detected, preserving free credits');
-        }
+        if (__DEV__) console.log('[SubscriptionInitializer] Free user detected, preserving free credits');
         return;
       }
 
       // If premium became false, check if actually expired or just canceled
       if (!isPremium && productId) {
-        // Check if subscription is truly expired (expiration date in the past)
         const isActuallyExpired = !expiresAt || new Date(expiresAt) < new Date();
-
         if (isActuallyExpired) {
-          // Subscription truly expired - zero out credits
           await getCreditsRepository().syncExpiredStatus(userId);
-          if (__DEV__) {
-            console.log('[SubscriptionInitializer] Subscription expired, synced status');
-          }
+          if (__DEV__) console.log('[SubscriptionInitializer] Subscription expired, synced status');
         } else {
-          // Subscription canceled but not expired - preserve credits until expiration
-          if (__DEV__) {
-            console.log('[SubscriptionInitializer] Subscription canceled but not expired, preserving credits until:', expiresAt);
-          }
-          // Update willRenew to false but keep credits
-          const revenueCatData: RevenueCatData = {
-            expirationDate: expiresAt,
-            willRenew: false, // Canceled
-            isPremium: true, // Still has access until expiration
-            periodType,
-          };
-          await getCreditsRepository().initializeCredits(
-            userId,
-            `status_sync_canceled_${Date.now()}`,
-            productId,
-            "settings" as any,
-            revenueCatData
-          );
+          if (__DEV__) console.log('[SubscriptionInitializer] Canceled but not expired, preserving until:', expiresAt);
+          const revenueCatData: RevenueCatData = { expirationDate: expiresAt, willRenew: false, isPremium: true, periodType };
+          await getCreditsRepository().initializeCredits(userId, `status_sync_canceled_${Date.now()}`, productId, "settings" as any, revenueCatData);
         }
         onCreditsUpdated?.(userId);
         return;
       }
 
       // Premium user - initialize credits with subscription data
-      const revenueCatData: RevenueCatData = {
-        expirationDate: expiresAt ?? null,
-        willRenew: willRenew ?? false,
-        isPremium,
-        periodType,
-      };
-      await getCreditsRepository().initializeCredits(
-        userId,
-        `status_sync_${Date.now()}`,
-        productId,
-        "settings" as any,
-        revenueCatData
-      );
-      if (__DEV__) {
-        console.log('[SubscriptionInitializer] Premium status synced to Firestore');
-      }
+      const revenueCatData: RevenueCatData = { expirationDate: expiresAt ?? null, willRenew: willRenew ?? false, isPremium, periodType };
+      await getCreditsRepository().initializeCredits(userId, `status_sync_${Date.now()}`, productId, "settings" as any, revenueCatData);
+      if (__DEV__) console.log('[SubscriptionInitializer] Premium status synced to Firestore');
       onCreditsUpdated?.(userId);
     } catch (error) {
-      if (__DEV__) {
-        console.error('[SubscriptionInitializer] Premium status sync failed:', error);
-      }
+      if (__DEV__) console.error('[SubscriptionInitializer] Premium status sync failed:', error);
     }
   };
 
@@ -216,22 +123,16 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
   });
 
   const userId = await waitForAuthState(getFirebaseAuth, authStateTimeoutMs);
-  
-  // Initialize subscription without blocking - let it complete in background
+
   try {
     if (timeoutMs > 0) {
-      const timeout = new Promise<boolean>((_, reject) => 
-        setTimeout(() => reject(new Error("Timeout")), timeoutMs)
-      );
+      const timeout = new Promise<boolean>((_, reject) => setTimeout(() => reject(new Error("Timeout")), timeoutMs));
       await Promise.race([SubscriptionManager.initialize(userId), timeout]);
     } else {
       await SubscriptionManager.initialize(userId);
     }
   } catch (error) {
-    // Log error but don't throw - subscription will continue in background
-    if (__DEV__) {
-      console.warn('[SubscriptionInitializer] Initialize timeout/error (non-critical):', error);
-    }
+    if (__DEV__) console.warn('[SubscriptionInitializer] Initialize timeout/error (non-critical):', error);
   }
 
   configureAuthProvider({

package/src/infrastructure/services/SubscriptionInitializerTypes.ts

@@ -0,0 +1,30 @@
+/**
+ * Subscription Initializer Types
+ */
+
+import type { CreditsConfig } from "../../domain/entities/Credits";
+
+export interface FirebaseAuthLike {
+  currentUser: { uid: string; isAnonymous: boolean } | null;
+  onAuthStateChanged: (callback: (user: { uid: string; isAnonymous: boolean } | null) => void) => () => void;
+}
+
+export interface CreditPackageConfig {
+  identifierPattern?: string;
+  amounts?: Record<string, number>;
+}
+
+export interface SubscriptionInitConfig {
+  apiKey?: string;
+  apiKeyIos?: string;
+  apiKeyAndroid?: string;
+  entitlementId: string;
+  credits: CreditsConfig;
+  getAnonymousUserId: () => Promise<string>;
+  getFirebaseAuth: () => FirebaseAuthLike | null;
+  showAuthModal: () => void;
+  onCreditsUpdated?: (userId: string) => void;
+  creditPackages?: CreditPackageConfig;
+  timeoutMs?: number;
+  authStateTimeoutMs?: number;
+}

package/src/infrastructure/services/TrialService.ts

@@ -1,63 +1,24 @@
 /**
- * Trial Service
- * Handles device-based trial tracking to prevent abuse
- * Uses persistent device ID that survives app reinstalls
+ * Trial Service - Device-based trial tracking to prevent abuse
  */
-
 declare const __DEV__: boolean;
 
-import {
-  doc,
-  getDoc,
-  setDoc,
-  serverTimestamp,
-  arrayUnion,
-} from "firebase/firestore";
+import { doc, getDoc, setDoc, serverTimestamp, arrayUnion } from "firebase/firestore";
 import { getFirestore } from "@umituz/react-native-firebase";
 import { PersistentDeviceIdService } from "@umituz/react-native-design-system";
+import type { TrialEligibilityResult } from "./TrialTypes";
 
-const DEVICE_TRIALS_COLLECTION = "device_trials";
+export { TRIAL_CONFIG, type DeviceTrialRecord, type TrialEligibilityResult } from "./TrialTypes";
 
-/** Trial constants */
-export const TRIAL_CONFIG = {
-  DURATION_DAYS: 3,
-  CREDITS: 5,
-} as const;
-
-/** Device trial record in Firestore */
-export interface DeviceTrialRecord {
-  deviceId: string;
-  hasUsedTrial: boolean;
-  trialInProgress?: boolean;
-  trialStartedAt?: Date;
-  trialEndedAt?: Date;
-  trialConvertedAt?: Date;
-  lastUserId?: string;
-  userIds: string[];
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-/** Trial eligibility result */
-export interface TrialEligibilityResult {
-  eligible: boolean;
-  reason?: "already_used" | "device_not_found" | "error";
-  deviceId?: string;
-}
+const DEVICE_TRIALS_COLLECTION = "device_trials";
 
-/**
- * Get persistent device ID
- */
+/** Get persistent device ID */
 export async function getDeviceId(): Promise<string> {
   return PersistentDeviceIdService.getDeviceId();
 }
 
-/**
- * Check if device is eligible for trial
- */
-export async function checkTrialEligibility(
-  deviceId?: string
-): Promise<TrialEligibilityResult> {
+/** Check if device is eligible for trial */
+export async function checkTrialEligibility(deviceId?: string): Promise<TrialEligibilityResult> {
   try {
     const effectiveDeviceId = deviceId || await getDeviceId();
     const db = getFirestore();
@@ -110,13 +71,8 @@ export async function checkTrialEligibility(
   }
 }
 
-/**
- * Record trial start for a device
- */
-export async function recordTrialStart(
-  userId: string,
-  deviceId?: string
-): Promise<boolean> {
+/** Record trial start for a device */
+export async function recordTrialStart(userId: string, deviceId?: string): Promise<boolean> {
   try {
     const effectiveDeviceId = deviceId || await getDeviceId();
     const db = getFirestore();
@@ -134,8 +90,6 @@ export async function recordTrialStart(
       trialRef,
       {
         deviceId: effectiveDeviceId,
-        // Don't set hasUsedTrial here - only set when trial ends or converts
-        // This allows retry if user cancels before trial period ends
         trialInProgress: true,
         trialStartedAt: serverTimestamp(),
         lastUserId: userId,
@@ -174,23 +128,18 @@ export async function recordTrialStart(
 /**
  * Record trial end (cancelled or expired)
  */
-export async function recordTrialEnd(
-  deviceId?: string
-): Promise<boolean> {
+export async function recordTrialEnd(deviceId?: string): Promise<boolean> {
   try {
     const effectiveDeviceId = deviceId || await getDeviceId();
     const db = getFirestore();
 
-    if (!db) {
-      return false;
-    }
+    if (!db) return false;
 
     const trialRef = doc(db, DEVICE_TRIALS_COLLECTION, effectiveDeviceId);
 
     await setDoc(
       trialRef,
       {
-        // Mark trial as used when it ends (prevents retry)
         hasUsedTrial: true,
         trialInProgress: false,
         trialEndedAt: serverTimestamp(),
@@ -215,23 +164,18 @@ export async function recordTrialEnd(
 /**
  * Record trial conversion to paid subscription
  */
-export async function recordTrialConversion(
-  deviceId?: string
-): Promise<boolean> {
+export async function recordTrialConversion(deviceId?: string): Promise<boolean> {
   try {
     const effectiveDeviceId = deviceId || await getDeviceId();
     const db = getFirestore();
 
-    if (!db) {
-      return false;
-    }
+    if (!db) return false;
 
     const trialRef = doc(db, DEVICE_TRIALS_COLLECTION, effectiveDeviceId);
 
     await setDoc(
       trialRef,
       {
-        // Mark trial as used after conversion (prevents retry)
         hasUsedTrial: true,
         trialInProgress: false,
         trialConvertedAt: serverTimestamp(),

package/src/infrastructure/services/TrialTypes.ts

@@ -0,0 +1,31 @@
+/**
+ * Trial Types and Constants
+ * Device-based trial tracking types
+ */
+
+/** Trial constants */
+export const TRIAL_CONFIG = {
+  DURATION_DAYS: 3,
+  CREDITS: 5,
+} as const;
+
+/** Device trial record in Firestore */
+export interface DeviceTrialRecord {
+  deviceId: string;
+  hasUsedTrial: boolean;
+  trialInProgress?: boolean;
+  trialStartedAt?: Date;
+  trialEndedAt?: Date;
+  trialConvertedAt?: Date;
+  lastUserId?: string;
+  userIds: string[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/** Trial eligibility result */
+export interface TrialEligibilityResult {
+  eligible: boolean;
+  reason?: "already_used" | "device_not_found" | "error";
+  deviceId?: string;
+}