@umituz/react-native-subscription 2.27.65 → 2.27.67

package/src/domains/subscription/application/SubscriptionSyncService.ts

@@ -0,0 +1,71 @@
+import type { CustomerInfo } from "react-native-purchases";
+import type { RevenueCatData } from "../core/RevenueCatData";
+import { type PeriodType, type PurchaseSource } from "../core/SubscriptionConstants";
+import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryProvider";
+import { extractRevenueCatData } from "./SubscriptionSyncUtils";
+import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
+
+/**
+ * Service to synchronize RevenueCat state with Firestore.
+ * Acts as a subscriber/handler for subscription events.
+ */
+export class SubscriptionSyncService {
+  constructor(private entitlementId: string) {}
+
+  async handlePurchase(userId: string, productId: string, customerInfo: CustomerInfo, source?: PurchaseSource) {
+    try {
+      const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
+      await getCreditsRepository().initializeCredits(userId, `purchase_${productId}_${Date.now()}`, productId, source, revenueCatData);
+      
+      // Notify listeners via Event Bus
+      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PURCHASE_COMPLETED, { userId, productId });
+    } catch (error) {
+      if (__DEV__) console.error('[SubscriptionSyncService] Credits init failed:', error);
+    }
+  }
+
+  async handleRenewal(userId: string, productId: string, newExpirationDate: string, customerInfo: CustomerInfo) {
+    try {
+      const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
+      revenueCatData.expirationDate = newExpirationDate || revenueCatData.expirationDate;
+      await getCreditsRepository().initializeCredits(userId, `renewal_${productId}_${Date.now()}`, productId, "renewal", revenueCatData);
+      
+      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.RENEWAL_DETECTED, { userId, productId });
+    } catch (error) {
+      if (__DEV__) console.error('[SubscriptionSyncService] Renewal credits init failed:', error);
+    }
+  }
+
+  async handlePremiumStatusChanged(
+    userId: string, 
+    isPremium: boolean, 
+    productId?: string,
+    expiresAt?: string, 
+    willRenew?: boolean, 
+    periodType?: PeriodType
+  ) {
+    try {
+      if (!isPremium && productId) {
+        await getCreditsRepository().syncExpiredStatus(userId);
+        subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+        return;
+      }
+
+      const revenueCatData: RevenueCatData = { 
+        expirationDate: expiresAt ?? null, 
+        willRenew: willRenew ?? false, 
+        isPremium, 
+        periodType 
+      };
+      
+      await getCreditsRepository().initializeCredits(userId, `status_sync_${Date.now()}`, productId, "settings", revenueCatData);
+      
+      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+      subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, { userId, isPremium });
+    } catch (error) {
+      if (__DEV__) console.error('[SubscriptionSyncService] Premium status sync failed:', error);
+    }
+  }
+}

package/src/domains/subscription/application/SubscriptionSyncUtils.ts

@@ -0,0 +1,16 @@
+import type { CustomerInfo } from "react-native-purchases";
+import type { RevenueCatData } from "../../domain/types/RevenueCatData";
+import { type PeriodType } from "../../domain/entities/SubscriptionConstants";
+
+/** Extract RevenueCat data from CustomerInfo (Single Source of Truth) */
+export 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,
+    periodType: entitlement?.periodType as PeriodType | undefined,
+  };
+};

package/src/{revenuecat/domain/value-objects → domains/subscription/core}/RevenueCatConfig.ts

@@ -1,5 +1,5 @@
 import type { CustomerInfo } from "react-native-purchases";
-import type { PurchaseSource } from "../../../domain/entities/Credits";
+import type { PurchaseSource } from "./SubscriptionConstants";
 
 export interface RevenueCatConfig {
   apiKey?: string;

package/src/{domain/types → domains/subscription/core}/RevenueCatData.ts

@@ -1,4 +1,4 @@
-import type { PeriodType } from "../entities/SubscriptionStatus";
+import type { PeriodType } from "./SubscriptionStatus";
 
 /**
  * RevenueCat subscription data (Single Source of Truth)

package/src/{domain/entities → domains/subscription/core}/SubscriptionStatus.ts

@@ -5,6 +5,11 @@ import {
   type PeriodType, 
   type SubscriptionStatusType 
 } from "./SubscriptionConstants";
+import { 
+  InactiveStatusHandler, 
+  TrialStatusHandler, 
+  ActiveStatusHandler 
+} from "./SubscriptionStatusHandlers";
 
 export { 
   SUBSCRIPTION_STATUS, 
@@ -21,9 +26,7 @@ export interface SubscriptionStatus {
     customerId?: string | null;
     syncedAt?: string | null;
     status?: SubscriptionStatusType;
-    /** RevenueCat period type: NORMAL, INTRO, or TRIAL */
     periodType?: PeriodType;
-    /** Whether user is currently in trial period */
     isTrialing?: boolean;
 }
 
@@ -40,7 +43,6 @@ export const createDefaultSubscriptionStatus = (): SubscriptionStatus => ({
 export const isSubscriptionValid = (status: SubscriptionStatus | null): boolean => {
     if (!status || !status.isPremium) return false;
     if (!status.expiresAt) return true; // Lifetime
-    
     return timezoneService.isFuture(new Date(status.expiresAt));
 };
 
@@ -49,7 +51,6 @@ export const calculateDaysRemaining = (expiresAt: string | null): number | null
     return timezoneService.getDaysUntil(new Date(expiresAt));
 };
 
-/** Subscription status resolver input */
 export interface StatusResolverInput {
     isPremium: boolean;
     willRenew?: boolean;
@@ -57,24 +58,15 @@ export interface StatusResolverInput {
     periodType?: PeriodType;
 }
 
+// Singleton Chain Instance
+const inactiveHandler = new InactiveStatusHandler();
+inactiveHandler
+    .setNext(new TrialStatusHandler())
+    .setNext(new ActiveStatusHandler());
+
 /**
- * Resolves subscription status from input parameters
- * Single source of truth for status determination logic
+ * Resolves subscription status using Chain of Responsibility Pattern.
  */
 export const resolveSubscriptionStatus = (input: StatusResolverInput): SubscriptionStatusType => {
-    const { isPremium, willRenew, isExpired, periodType } = input;
-
-    if (!isPremium || isExpired) {
-        return isExpired ? SUBSCRIPTION_STATUS.EXPIRED : SUBSCRIPTION_STATUS.NONE;
-    }
-
-    const isTrial = periodType === PERIOD_TYPE.TRIAL;
-    const isCanceled = willRenew === false;
-
-    if (isTrial) {
-        return isCanceled ? SUBSCRIPTION_STATUS.TRIAL_CANCELED : SUBSCRIPTION_STATUS.TRIAL;
-    }
-
-    return isCanceled ? SUBSCRIPTION_STATUS.CANCELED : SUBSCRIPTION_STATUS.ACTIVE;
+    return inactiveHandler.handle(input);
 };
-

package/src/domains/subscription/core/SubscriptionStatusHandlers.ts

@@ -0,0 +1,51 @@
+import { 
+  SUBSCRIPTION_STATUS, 
+  PERIOD_TYPE, 
+  type SubscriptionStatusType 
+} from "./SubscriptionConstants";
+import type { StatusResolverInput } from "./SubscriptionStatus";
+
+export abstract class BaseStatusHandler {
+    protected next?: BaseStatusHandler;
+
+    setNext(handler: BaseStatusHandler): BaseStatusHandler {
+        this.next = handler;
+        return handler;
+    }
+
+    abstract handle(input: StatusResolverInput): SubscriptionStatusType;
+
+    protected nextOrFallback(input: StatusResolverInput, fallback: SubscriptionStatusType): SubscriptionStatusType {
+        return this.next ? this.next.handle(input) : fallback;
+    }
+}
+
+/** Handles Expired or No-Premium cases */
+export class InactiveStatusHandler extends BaseStatusHandler {
+    handle(input: StatusResolverInput): SubscriptionStatusType {
+        if (!input.isPremium || input.isExpired) {
+            return input.isExpired ? SUBSCRIPTION_STATUS.EXPIRED : SUBSCRIPTION_STATUS.NONE;
+        }
+        return this.nextOrFallback(input, SUBSCRIPTION_STATUS.NONE);
+    }
+}
+
+/** Handles Trial-related states */
+export class TrialStatusHandler extends BaseStatusHandler {
+    handle(input: StatusResolverInput): SubscriptionStatusType {
+        if (input.periodType === PERIOD_TYPE.TRIAL) {
+            return input.willRenew === false ? SUBSCRIPTION_STATUS.TRIAL_CANCELED : SUBSCRIPTION_STATUS.TRIAL;
+        }
+        return this.nextOrFallback(input, SUBSCRIPTION_STATUS.ACTIVE);
+    }
+}
+
+/** Handles Canceled-Active states */
+export class ActiveStatusHandler extends BaseStatusHandler {
+    handle(input: StatusResolverInput): SubscriptionStatusType {
+        if (input.willRenew === false) {
+            return SUBSCRIPTION_STATUS.CANCELED;
+        }
+        return SUBSCRIPTION_STATUS.ACTIVE;
+    }
+}

package/src/domains/subscription/infrastructure/handlers/PackageHandler.ts

@@ -0,0 +1,67 @@
+/**
+ * Package Handler
+ * Handles operations: fetch, purchase, restore
+ */
+
+import type { PurchasesPackage, CustomerInfo } from "react-native-purchases";
+import type { IRevenueCatService } from "../../application/ports/IRevenueCatService";
+import { getPremiumEntitlement } from "../../domain/types/RevenueCatTypes";
+import { PurchaseStatusResolver, type PremiumStatus } from "./PurchaseStatusResolver";
+
+export interface RestoreResultInfo {
+  success: boolean;
+  productId: string | null;
+}
+
+export class PackageHandler {
+  constructor(
+    private service: IRevenueCatService | null,
+    private entitlementId: string
+  ) { }
+
+  setService = (service: IRevenueCatService | null) => { this.service = service; };
+
+  async fetchPackages(): Promise<PurchasesPackage[]> {
+    if (!this.service?.isInitialized()) return [];
+    try {
+      const offering = await this.service.fetchOfferings();
+      return offering?.availablePackages ?? [];
+    } catch (error) {
+      if (__DEV__) console.error('[PackageHandler] fetchOfferings failed:', error);
+      return [];
+    }
+  }
+
+  async purchase(pkg: PurchasesPackage, userId: string): Promise<boolean> {
+    if (!this.service?.isInitialized()) return false;
+    try {
+      const result = await this.service.purchasePackage(pkg, userId);
+      return result.success;
+    } catch (error) {
+      if (__DEV__) console.error('[PackageHandler] Purchase failed:', error);
+      return false;
+    }
+  }
+
+  async restore(userId: string): Promise<RestoreResultInfo> {
+    if (!this.service?.isInitialized()) return { success: false, productId: null };
+    try {
+      const result = await this.service.restorePurchases(userId);
+      let productId: string | null = null;
+      if (result.success && result.customerInfo) {
+        const entitlement = getPremiumEntitlement(result.customerInfo, this.entitlementId);
+        if (entitlement) productId = entitlement.productIdentifier;
+      }
+      return { success: result.success, productId };
+    } catch (error) {
+      if (__DEV__) console.error('[PackageHandler] Restore failed:', error);
+      return { success: false, productId: null };
+    }
+  }
+
+  checkPremiumStatusFromInfo(customerInfo: CustomerInfo): PremiumStatus {
+    return PurchaseStatusResolver.resolve(customerInfo, this.entitlementId);
+  }
+}
+
+export type { PremiumStatus };

package/src/domains/subscription/infrastructure/handlers/PurchaseStatusResolver.ts

@@ -0,0 +1,27 @@
+import type { CustomerInfo } from "react-native-purchases";
+import { getPremiumEntitlement } from "../../domain/types/RevenueCatTypes";
+
+export interface PremiumStatus {
+  isPremium: boolean;
+  expirationDate: Date | null;
+}
+
+export class PurchaseStatusResolver {
+  static resolve(customerInfo: CustomerInfo, entitlementId: string): PremiumStatus {
+    const entitlement = getPremiumEntitlement(customerInfo, entitlementId);
+
+    if (entitlement) {
+      return {
+        isPremium: true,
+        expirationDate: entitlement.expirationDate
+          ? new Date(entitlement.expirationDate)
+          : null,
+      };
+    }
+
+    return {
+      isPremium: false,
+      expirationDate: null,
+    };
+  }
+}

package/src/domains/subscription/infrastructure/managers/SubscriptionInternalState.ts

@@ -0,0 +1,12 @@
+import { UserIdProvider } from "../utils/UserIdProvider";
+import { InitializationCache } from "../utils/InitializationCache";
+
+export class SubscriptionInternalState {
+  public userIdProvider = new UserIdProvider();
+  public initCache = new InitializationCache();
+  
+  reset() {
+    this.userIdProvider.reset();
+    this.initCache.reset();
+  }
+}

package/src/domains/subscription/infrastructure/managers/SubscriptionManager.ts

@@ -0,0 +1,110 @@
+/**
+ * Subscription Manager
+ * Facade for subscription operations. Coordinates state and operations.
+ */
+
+import type { PurchasesPackage } from "react-native-purchases";
+import type { RevenueCatConfig } from "../../core/RevenueCatConfig";
+import type { IRevenueCatService } from "../../../../shared/application/ports/IRevenueCatService";
+import { initializeRevenueCatService, getRevenueCatService } from "../services/RevenueCatService";
+import { PackageHandler } from "../handlers/PackageHandler";
+import type { PremiumStatus, RestoreResultInfo } from "../handlers/PackageHandler";
+import { SubscriptionInternalState } from "./SubscriptionInternalState";
+
+export interface SubscriptionManagerConfig {
+  config: RevenueCatConfig;
+  apiKey: string;
+  getAnonymousUserId?: () => Promise<string>;
+}
+
+class SubscriptionManagerImpl {
+  private managerConfig: SubscriptionManagerConfig | null = null;
+  private serviceInstance: IRevenueCatService | null = null;
+  private state = new SubscriptionInternalState();
+  private packageHandler: PackageHandler | null = null;
+
+  configure(config: SubscriptionManagerConfig): void {
+    this.managerConfig = config;
+    this.packageHandler = new PackageHandler(null, config.config.entitlementIdentifier);
+    if (config.getAnonymousUserId) this.state.userIdProvider.configure(config.getAnonymousUserId);
+  }
+
+  private ensureConfigured(): void {
+    if (!this.managerConfig || !this.packageHandler) throw new Error("SubscriptionManager not configured");
+  }
+
+  async initialize(userId?: string): Promise<boolean> {
+    this.ensureConfigured();
+    const effectiveUserId = userId || (await this.state.userIdProvider.getOrCreateAnonymousUserId());
+    const { shouldInit, existingPromise } = this.state.initCache.tryAcquireInitialization(effectiveUserId);
+
+    if (!shouldInit && existingPromise) return existingPromise;
+
+    const promise = (async () => {
+        await initializeRevenueCatService(this.managerConfig!.config);
+        this.serviceInstance = getRevenueCatService();
+        if (!this.serviceInstance) return false;
+        this.packageHandler!.setService(this.serviceInstance);
+        const result = await this.serviceInstance.initialize(effectiveUserId);
+        return result.success;
+    })();
+
+    this.state.initCache.setPromise(promise, effectiveUserId);
+    return promise;
+  }
+
+  isInitializedForUser(userId: string): boolean {
+    return this.serviceInstance?.isInitialized() === true && this.state.initCache.getCurrentUserId() === userId;
+  }
+
+  async getPackages(): Promise<PurchasesPackage[]> {
+    this.ensureConfigured();
+    if (!this.serviceInstance) {
+      this.serviceInstance = getRevenueCatService();
+      this.packageHandler!.setService(this.serviceInstance);
+    }
+    return this.packageHandler!.fetchPackages();
+  }
+
+  async purchasePackage(pkg: PurchasesPackage): Promise<boolean> {
+    this.ensureConfigured();
+    const userId = this.state.initCache.getCurrentUserId();
+    if (!userId) return false;
+    return this.packageHandler!.purchase(pkg, userId);
+  }
+
+  async restore(): Promise<RestoreResultInfo> {
+    this.ensureConfigured();
+    const userId = this.state.initCache.getCurrentUserId();
+    if (!userId) return { success: false, productId: null };
+    return this.packageHandler!.restore(userId);
+  }
+
+  async checkPremiumStatus(): Promise<PremiumStatus> {
+    this.ensureConfigured();
+    const userId = this.state.initCache.getCurrentUserId();
+    if (!userId) return { isPremium: false, expirationDate: null };
+
+    try {
+      const customerInfo = await this.serviceInstance?.getCustomerInfo();
+      if (customerInfo) return this.packageHandler!.checkPremiumStatusFromInfo(customerInfo);
+    } catch (error) {
+      throw error;
+    }
+    return { isPremium: false, expirationDate: null };
+  }
+
+  async reset(): Promise<void> {
+    if (this.serviceInstance) await this.serviceInstance.reset();
+    this.state.reset();
+    this.serviceInstance = null;
+  }
+
+  // Helper status checks
+  isConfigured = () => !!this.managerConfig;
+  isInitialized = () => this.serviceInstance?.isInitialized() ?? false;
+  getEntitlementId = () => this.managerConfig?.config.entitlementIdentifier || null;
+}
+
+export const SubscriptionManager = new SubscriptionManagerImpl();
+export type { PremiumStatus };

package/src/{presentation/hooks → domains/subscription/presentation}/usePremium.ts

@@ -7,14 +7,14 @@
 
 import { useCallback } from 'react';
 import type { PurchasesPackage } from 'react-native-purchases';
-import type { UserCredits } from '../../domain/entities/Credits';
-import { useCredits } from './useCredits';
+import type { UserCredits } from '../../credits/core/Credits';
+import { useCredits } from '../../credits/presentation/useCredits';
 import { useSubscriptionStatus } from './useSubscriptionStatus';
 import {
   useSubscriptionPackages,
   usePurchasePackage,
   useRestorePurchase,
-} from '../../revenuecat/presentation/hooks/useSubscriptionQueries';
+} from '../infrastructure/hooks/useSubscriptionQueries';
 import { usePaywallVisibility } from './usePaywallVisibility';
 
 export interface UsePremiumResult {
@@ -23,6 +23,7 @@ export interface UsePremiumResult {
   packages: PurchasesPackage[];
   credits: UserCredits | null;
   showPaywall: boolean;
+  isSyncing: boolean;
   purchasePackage: (pkg: PurchasesPackage) => Promise<boolean>;
   restorePurchase: () => Promise<boolean>;
   setShowPaywall: (show: boolean) => void;
@@ -40,8 +41,9 @@ export const usePremium = (): UsePremiumResult => {
   const restoreMutation = useRestorePurchase();
 
   const { showPaywall, setShowPaywall, closePaywall, openPaywall } = usePaywallVisibility();
-
+ 
   const isPremium = subscriptionActive;
+  const isSyncing = subscriptionActive && credits !== null && !credits.isPremium;
 
   const handlePurchase = useCallback(
     async (pkg: PurchasesPackage): Promise<boolean> => {
@@ -84,6 +86,7 @@ export const usePremium = (): UsePremiumResult => {
     packages,
     credits,
     showPaywall,
+    isSyncing,
     purchasePackage: handlePurchase,
     restorePurchase: handleRestore,
     setShowPaywall,

package/src/domains/trial/application/TrialEligibilityService.ts

@@ -0,0 +1,25 @@
+import type { TrialEligibilityResult, DeviceTrialRecord } from "./TrialTypes";
+
+export class TrialEligibilityService {
+  static check(
+    userId: string | undefined, 
+    deviceId: string, 
+    record: DeviceTrialRecord | null
+  ): TrialEligibilityResult {
+    if (!record) {
+      return { eligible: true, deviceId };
+    }
+
+    const { hasUsedTrial, trialInProgress, userIds = [] } = record;
+
+    if (userId && userIds.includes(userId)) {
+      return { eligible: false, reason: "user_already_used", deviceId };
+    }
+
+    if (hasUsedTrial || trialInProgress) {
+      return { eligible: false, reason: "already_used", deviceId };
+    }
+
+    return { eligible: true, deviceId };
+  }
+}

package/src/domains/trial/application/TrialService.ts

@@ -0,0 +1,68 @@
+/**
+ * Trial Service - Facade for device-based trial tracking
+ */
+
+import { arrayUnion, serverTimestamp } from "firebase/firestore";
+import { PersistentDeviceIdService } from "@umituz/react-native-design-system";
+import { DeviceTrialRepository } from "../infrastructure/DeviceTrialRepository";
+import { TrialEligibilityService } from "./TrialEligibilityService";
+import type { TrialEligibilityResult } from "../core/TrialTypes";
+
+const repository = new DeviceTrialRepository();
+
+export const getDeviceId = () => PersistentDeviceIdService.getDeviceId();
+
+export async function checkTrialEligibility(userId?: string, deviceId?: string): Promise<TrialEligibilityResult> {
+  try {
+    const id = deviceId || await getDeviceId();
+    const record = await repository.getRecord(id);
+    return TrialEligibilityService.check(userId, id, record);
+  } catch (error) {
+    if (__DEV__) console.error("[TrialService] Eligibility check error:", error);
+    return { eligible: false, reason: "error" };
+  }
+}
+
+export async function recordTrialStart(userId: string, deviceId?: string): Promise<boolean> {
+  try {
+    const id = deviceId || await getDeviceId();
+    return await repository.saveRecord(id, {
+      deviceId: id,
+      trialInProgress: true,
+      trialStartedAt: serverTimestamp() as any,
+      lastUserId: userId,
+      userIds: arrayUnion(userId) as any,
+    });
+  } catch (error) {
+    if (__DEV__) console.error("[TrialService] Record trial error:", error);
+    return false;
+  }
+}
+
+export async function recordTrialEnd(deviceId?: string): Promise<boolean> {
+  try {
+    const id = deviceId || await getDeviceId();
+    return await repository.saveRecord(id, {
+      hasUsedTrial: true,
+      trialInProgress: false,
+      trialEndedAt: serverTimestamp() as any,
+    });
+  } catch (error) {
+    if (__DEV__) console.error("[TrialService] Record trial end error:", error);
+    return false;
+  }
+}
+
+export async function recordTrialConversion(deviceId?: string): Promise<boolean> {
+  try {
+    const id = deviceId || await getDeviceId();
+    return await repository.saveRecord(id, {
+      hasUsedTrial: true,
+      trialInProgress: false,
+      trialConvertedAt: serverTimestamp() as any,
+    });
+  } catch (error) {
+    if (__DEV__) console.error("[TrialService] Record conversion error:", error);
+    return false;
+  }
+}

package/src/{infrastructure/services → domains/trial/core}/TrialTypes.ts

@@ -26,6 +26,6 @@ export interface DeviceTrialRecord {
 /** Trial eligibility result */
 export interface TrialEligibilityResult {
   eligible: boolean;
-  reason?: "already_used" | "device_not_found" | "error";
+  reason?: "already_used" | "device_not_found" | "error" | "user_already_used";
   deviceId?: string;
 }

package/src/domains/trial/infrastructure/DeviceTrialRepository.ts

@@ -0,0 +1,30 @@
+import { doc, getDoc, setDoc, serverTimestamp, arrayUnion, type Firestore } from "firebase/firestore";
+import { getFirestore } from "@umituz/react-native-firebase";
+import type { DeviceTrialRecord } from "./TrialTypes";
+
+const DEVICE_TRIALS_COLLECTION = "device_trials";
+
+export class DeviceTrialRepository {
+  private get db(): Firestore | null {
+    return getFirestore();
+  }
+
+  async getRecord(deviceId: string): Promise<DeviceTrialRecord | null> {
+    if (!this.db) return null;
+    const snap = await getDoc(doc(this.db, DEVICE_TRIALS_COLLECTION, deviceId));
+    return snap.exists() ? snap.data() as DeviceTrialRecord : null;
+  }
+
+  async saveRecord(deviceId: string, data: Partial<DeviceTrialRecord>): Promise<boolean> {
+    if (!this.db) return false;
+    const ref = doc(this.db, DEVICE_TRIALS_COLLECTION, deviceId);
+    await setDoc(ref, { ...data, updatedAt: serverTimestamp() }, { merge: true });
+    
+    // Ensure createdAt exists
+    const snap = await getDoc(ref);
+    if (!snap.data()?.createdAt) {
+      await setDoc(ref, { createdAt: serverTimestamp() }, { merge: true });
+    }
+    return true;
+  }
+}

package/src/presentation/components/details/PremiumStatusBadge.tsx

@@ -33,14 +33,14 @@ export const PremiumStatusBadge: React.FC<PremiumStatusBadgeProps> = ({
 }) => {
   const tokens = useAppDesignTokens();
 
-  const labels: Record<SubscriptionStatusType, string> = {
+  const labels: Record<SubscriptionStatusType, string> = useMemo(() => ({
     [SUBSCRIPTION_STATUS.ACTIVE]: activeLabel,
     [SUBSCRIPTION_STATUS.TRIAL]: activeLabel,
     [SUBSCRIPTION_STATUS.TRIAL_CANCELED]: trialCanceledLabel ?? canceledLabel,
     [SUBSCRIPTION_STATUS.EXPIRED]: expiredLabel,
     [SUBSCRIPTION_STATUS.NONE]: noneLabel,
     [SUBSCRIPTION_STATUS.CANCELED]: canceledLabel,
-  };
+  }), [activeLabel, trialCanceledLabel, canceledLabel, expiredLabel, noneLabel]);
 
   const backgroundColor = useMemo(() => {
     const colors: Record<SubscriptionStatusType, string> = {

package/src/presentation/hooks/index.ts

@@ -1,13 +1,13 @@
-export * from "./useAuthAwarePurchase";
-export * from "./useAuthSubscriptionSync";
-export * from "./useSavedPurchaseAutoExecution";
-export * from "./useCredits";
-export * from "./useDeductCredit";
-export * from "./useFeatureGate";
-export * from "./usePaywallVisibility";
-export * from "./usePremium";
-export * from "./usePremiumGate";
-export * from "./useSubscriptionSettingsConfig";
-export * from "./useSubscriptionStatus";
+export * from "../../domains/subscription/presentation/useAuthAwarePurchase";
+export * from "../../domains/subscription/presentation/useAuthSubscriptionSync";
+export * from "../../domains/subscription/presentation/useSavedPurchaseAutoExecution";
+export * from "../../domains/credits/presentation/useCredits";
+export * from "../../domains/credits/presentation/useDeductCredit";
+export * from "../../domains/subscription/presentation/useFeatureGate";
+export * from "../../domains/subscription/presentation/usePaywallVisibility";
+export * from "../../domains/subscription/presentation/usePremium";
+export * from "../../domains/subscription/presentation/usePremiumGate";
+export * from "../../domains/subscription/presentation/useSubscriptionSettingsConfig";
+export * from "../../domains/subscription/presentation/useSubscriptionStatus";
 export * from "./feedback/usePaywallFeedback";
 export * from "./feedback/useFeedbackSubmit";