@umituz/react-native-subscription 2.25.0 → 2.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "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/entities/Credits.ts

@@ -6,6 +6,7 @@
  */
 
 import type { SubscriptionPackageType } from "../../utils/packageTypeDetector";
+import type { SubscriptionStatusType, PeriodType } from "./SubscriptionStatus";
 
 export type CreditType = "text" | "image";
 
@@ -19,16 +20,11 @@ export type PurchaseSource =
 
 export type PurchaseType = "initial" | "renewal" | "upgrade" | "downgrade";
 
-export type SubscriptionStatus = "active" | "trial" | "trial_canceled" | "expired" | "canceled" | "free";
-
-/** RevenueCat period types */
-export type PeriodType = "NORMAL" | "INTRO" | "TRIAL";
-
 /** Single Source of Truth for user subscription + credits data */
 export interface UserCredits {
   // Core subscription
   isPremium: boolean;
-  status: SubscriptionStatus;
+  status: SubscriptionStatusType;
 
   // Dates
   purchasedAt: Date | null;

package/src/domain/entities/SubscriptionStatus.ts

@@ -9,8 +9,14 @@ export const SUBSCRIPTION_STATUS = {
   NONE: 'none',
 } as const;
 
-/** RevenueCat period types */
-export type PeriodType = "NORMAL" | "INTRO" | "TRIAL";
+/** RevenueCat period type constants */
+export const PERIOD_TYPE = {
+  NORMAL: 'NORMAL',
+  INTRO: 'INTRO',
+  TRIAL: 'TRIAL',
+} as const;
+
+export type PeriodType = (typeof PERIOD_TYPE)[keyof typeof PERIOD_TYPE];
 
 export type SubscriptionStatusType = (typeof SUBSCRIPTION_STATUS)[keyof typeof SUBSCRIPTION_STATUS];
 
@@ -35,7 +41,7 @@ export const createDefaultSubscriptionStatus = (): SubscriptionStatus => ({
     purchasedAt: null,
     customerId: null,
     syncedAt: null,
-    status: 'none',
+    status: SUBSCRIPTION_STATUS.NONE,
 });
 
 export const isSubscriptionValid = (status: SubscriptionStatus | null): boolean => {
@@ -50,3 +56,32 @@ 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;
+    isExpired?: boolean;
+    periodType?: PeriodType;
+}
+
+/**
+ * Resolves subscription status from input parameters
+ * Single source of truth for status determination logic
+ */
+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;
+};
+

package/src/domain/value-objects/Result.ts

@@ -0,0 +1,128 @@
+/**
+ * Result Pattern
+ * Type-safe error handling without exceptions.
+ * Inspired by Rust's Result<T, E> and functional programming patterns.
+ */
+
+/** Success result containing data */
+export interface Success<T> {
+  readonly success: true;
+  readonly data: T;
+  readonly error?: never;
+}
+
+/** Failure result containing error */
+export interface Failure<E = Error> {
+  readonly success: false;
+  readonly data?: never;
+  readonly error: E;
+}
+
+/** Union type representing either success or failure */
+export type Result<T, E = Error> = Success<T> | Failure<E>;
+
+/** Create a success result */
+export function success<T>(data: T): Success<T> {
+  return { success: true, data };
+}
+
+/** Create a failure result */
+export function failure<E = Error>(error: E): Failure<E> {
+  return { success: false, error };
+}
+
+/** Type guard to check if result is success */
+export function isSuccess<T, E>(result: Result<T, E>): result is Success<T> {
+  return result.success === true;
+}
+
+/** Type guard to check if result is failure */
+export function isFailure<T, E>(result: Result<T, E>): result is Failure<E> {
+  return result.success === false;
+}
+
+/** Unwrap result or throw if failure */
+export function unwrap<T, E extends Error>(result: Result<T, E>): T {
+  if (isSuccess(result)) {
+    return result.data;
+  }
+  throw result.error;
+}
+
+/** Unwrap result or return default value */
+export function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {
+  if (isSuccess(result)) {
+    return result.data;
+  }
+  return defaultValue;
+}
+
+/** Map success value to new value */
+export function map<T, U, E>(
+  result: Result<T, E>,
+  fn: (data: T) => U
+): Result<U, E> {
+  if (isSuccess(result)) {
+    return success(fn(result.data));
+  }
+  return result;
+}
+
+/** Chain results (flatMap) */
+export function flatMap<T, U, E>(
+  result: Result<T, E>,
+  fn: (data: T) => Result<U, E>
+): Result<U, E> {
+  if (isSuccess(result)) {
+    return fn(result.data);
+  }
+  return result;
+}
+
+/** Execute async function and wrap result */
+export async function tryCatch<T>(
+  fn: () => Promise<T>,
+  errorMapper?: (error: unknown) => Error
+): Promise<Result<T, Error>> {
+  try {
+    const data = await fn();
+    return success(data);
+  } catch (error) {
+    const mappedError = errorMapper
+      ? errorMapper(error)
+      : error instanceof Error
+        ? error
+        : new Error(String(error));
+    return failure(mappedError);
+  }
+}
+
+/** Execute sync function and wrap result */
+export function tryCatchSync<T>(
+  fn: () => T,
+  errorMapper?: (error: unknown) => Error
+): Result<T, Error> {
+  try {
+    const data = fn();
+    return success(data);
+  } catch (error) {
+    const mappedError = errorMapper
+      ? errorMapper(error)
+      : error instanceof Error
+        ? error
+        : new Error(String(error));
+    return failure(mappedError);
+  }
+}
+
+/** Combine multiple results into one */
+export function combine<T, E>(results: Result<T, E>[]): Result<T[], E> {
+  const data: T[] = [];
+  for (const result of results) {
+    if (isFailure(result)) {
+      return result;
+    }
+    data.push(result.data);
+  }
+  return success(data);
+}

package/src/index.ts

@@ -7,11 +7,33 @@ export * from "./domains/paywall";
 export * from "./domains/config";
 
 // Domain Layer
-export { createDefaultSubscriptionStatus, isSubscriptionValid } from "./domain/entities/SubscriptionStatus";
-export type { SubscriptionStatus, SubscriptionStatusType, PeriodType } from "./domain/entities/SubscriptionStatus";
+export {
+  SUBSCRIPTION_STATUS,
+  PERIOD_TYPE,
+  createDefaultSubscriptionStatus,
+  isSubscriptionValid,
+  resolveSubscriptionStatus,
+} from "./domain/entities/SubscriptionStatus";
+export type { SubscriptionStatus, SubscriptionStatusType, PeriodType, StatusResolverInput } from "./domain/entities/SubscriptionStatus";
 export type { SubscriptionConfig } from "./domain/value-objects/SubscriptionConfig";
 export type { ISubscriptionRepository } from "./application/ports/ISubscriptionRepository";
 
+// Result Pattern (Functional Error Handling)
+export {
+  success,
+  failure,
+  isSuccess,
+  isFailure,
+  unwrap,
+  unwrapOr,
+  map,
+  flatMap,
+  tryCatch,
+  tryCatchSync,
+  combine,
+} from "./domain/value-objects/Result";
+export type { Result, Success, Failure } from "./domain/value-objects/Result";
+
 // Infrastructure Layer
 export { SubscriptionService, initializeSubscriptionService } from "./infrastructure/services/SubscriptionService";
 export {

package/src/infrastructure/mappers/CreditsMapper.ts

@@ -1,4 +1,5 @@
-import type { UserCredits, SubscriptionStatus, PeriodType } from "../../domain/entities/Credits";
+import type { UserCredits } from "../../domain/entities/Credits";
+import { resolveSubscriptionStatus, type PeriodType, type SubscriptionStatusType } from "../../domain/entities/SubscriptionStatus";
 import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
 
 /** Maps Firestore document to domain entity with expiration validation */
@@ -51,43 +52,22 @@ export class CreditsMapper {
     doc: UserCreditsDocumentRead,
     expirationDate: Date | null,
     periodType?: PeriodType
-  ): { isPremium: boolean; status: SubscriptionStatus } {
-    const docIsPremium = doc.isPremium ?? false;
+  ): { isPremium: boolean; status: SubscriptionStatusType } {
+    const isPremium = doc.isPremium ?? false;
     const willRenew = doc.willRenew ?? false;
+    const isExpired = expirationDate ? expirationDate < new Date() : false;
 
-    // No expiration date = lifetime or free
-    if (!expirationDate) {
-      return {
-        isPremium: docIsPremium,
-        status: docIsPremium ? "active" : "free",
-      };
-    }
-
-    // Check if subscription has expired
-    const isExpired = expirationDate < new Date();
-
-    if (isExpired) {
-      // Subscription expired - override document's isPremium
-      return { isPremium: false, status: "expired" };
-    }
-
-    // Handle trial period
-    if (periodType === "TRIAL") {
-      return {
-        isPremium: docIsPremium,
-        status: willRenew === false ? "trial_canceled" : "trial",
-      };
-    }
-
-    // Handle canceled subscription (will not renew but still active)
-    if (docIsPremium && willRenew === false) {
-      return { isPremium: true, status: "canceled" };
-    }
+    const status = resolveSubscriptionStatus({
+      isPremium,
+      willRenew,
+      isExpired,
+      periodType,
+    });
 
-    // Subscription still active
+    // Override isPremium if expired
     return {
-      isPremium: docIsPremium,
-      status: docIsPremium ? "active" : "free",
+      isPremium: isExpired ? false : isPremium,
+      status,
     };
   }
 }

package/src/infrastructure/services/CreditsInitializer.ts

@@ -15,9 +15,8 @@ import type {
   PurchaseSource,
   PurchaseType,
   PurchaseMetadata,
-  SubscriptionDocStatus,
-  PeriodType,
 } from "../models/UserCreditsDocument";
+import { SUBSCRIPTION_STATUS, resolveSubscriptionStatus, type PeriodType } from "../../domain/entities/SubscriptionStatus";
 import { TRIAL_CONFIG } from "./TrialService";
 import { detectPackageType } from "../../utils/packageTypeDetector";
 import { getCreditAllocation } from "../../utils/creditMapper";
@@ -126,34 +125,23 @@ export async function initializeCreditsTransaction(
           ? [...(existing?.purchaseHistory || []), purchaseMetadata].slice(-10)
           : existing?.purchaseHistory;
 
-        // Determine subscription status based on isPremium, willRenew, and periodType
+        // Determine subscription status
         const isPremium = metadata?.isPremium ?? true;
         const willRenew = metadata?.willRenew;
         const periodType = metadata?.periodType;
-        const isTrialing = periodType === "TRIAL";
-
-        // Status logic:
-        // - trial: periodType is TRIAL and premium
-        // - trial_canceled: periodType is TRIAL and premium but willRenew=false
-        // - canceled: premium but willRenew=false (non-trial)
-        // - expired: not premium
-        // - active: premium and will renew (non-trial)
-        let status: SubscriptionDocStatus;
-        if (!isPremium) {
-            status = "expired";
-        } else if (isTrialing) {
-            status = willRenew === false ? "trial_canceled" : "trial";
-        } else if (willRenew === false) {
-            status = "canceled";
-        } else {
-            status = "active";
-        }
+
+        const status = resolveSubscriptionStatus({
+            isPremium,
+            willRenew,
+            isExpired: !isPremium,
+            periodType,
+        });
 
         // Determine credits based on status
         // Trial: 5 credits, Trial canceled: 0 credits, Normal: plan-based credits
-        if (status === "trial") {
+        if (status === SUBSCRIPTION_STATUS.TRIAL) {
             newCredits = TRIAL_CONFIG.CREDITS;
-        } else if (status === "trial_canceled") {
+        } else if (status === SUBSCRIPTION_STATUS.TRIAL_CANCELED) {
             newCredits = 0;
         }
 
@@ -198,11 +186,13 @@ export async function initializeCreditsTransaction(
         }
 
         // Trial-specific fields
+        const isTrialing = status === SUBSCRIPTION_STATUS.TRIAL || status === SUBSCRIPTION_STATUS.TRIAL_CANCELED;
+
         if (periodType) {
             creditsData.periodType = periodType;
         }
         if (isTrialing) {
-            creditsData.isTrialing = true;
+            creditsData.isTrialing = status === SUBSCRIPTION_STATUS.TRIAL;
             creditsData.trialCredits = TRIAL_CONFIG.CREDITS;
             // Set trial dates if this is a new trial
             if (!existing?.trialStartDate) {
@@ -211,7 +201,7 @@ export async function initializeCreditsTransaction(
             if (metadata?.expirationDate) {
                 creditsData.trialEndDate = Timestamp.fromDate(new Date(metadata.expirationDate));
             }
-        } else if (existing?.isTrialing && !isTrialing && isPremium) {
+        } else if (existing?.isTrialing && isPremium) {
             // User converted from trial to paid
             creditsData.isTrialing = false;
             creditsData.convertedFromTrial = true;

package/src/infrastructure/utils/Logger.ts

@@ -0,0 +1,114 @@
+/**
+ * Subscription Logger
+ * Centralized logging utility for the subscription package.
+ * All logs are dev-only and automatically stripped in production.
+ */
+
+declare const __DEV__: boolean;
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface LogContext {
+  [key: string]: unknown;
+}
+
+/** Log categories for filtering and grouping */
+export const LOG_CATEGORY = {
+  REVENUECAT: "RevenueCat",
+  CREDITS: "Credits",
+  TRIAL: "Trial",
+  PURCHASE: "Purchase",
+  FEATURE_GATE: "FeatureGate",
+  SUBSCRIPTION: "Subscription",
+  SYNC: "Sync",
+} as const;
+
+export type LogCategory = (typeof LOG_CATEGORY)[keyof typeof LOG_CATEGORY];
+
+/**
+ * Development-only logger that automatically respects __DEV__ flag.
+ * All methods are no-ops in production builds.
+ */
+class SubscriptionLogger {
+  private enabled: boolean = true;
+  private categories: Set<LogCategory> = new Set();
+
+  /** Enable or disable all logging */
+  setEnabled(enabled: boolean): void {
+    this.enabled = enabled;
+  }
+
+  /** Enable logging for specific categories only */
+  setCategories(categories: LogCategory[]): void {
+    this.categories = new Set(categories);
+  }
+
+  /** Clear category filter (log all categories) */
+  clearCategories(): void {
+    this.categories.clear();
+  }
+
+  private shouldLog(category?: LogCategory): boolean {
+    if (typeof __DEV__ === "undefined" || !__DEV__) return false;
+    if (!this.enabled) return false;
+    if (this.categories.size > 0 && category && !this.categories.has(category)) return false;
+    return true;
+  }
+
+  private formatMessage(category: LogCategory | string, message: string): string {
+    return `[${category}] ${message}`;
+  }
+
+  debug(category: LogCategory, message: string, context?: LogContext): void {
+    if (!this.shouldLog(category)) return;
+    console.log(this.formatMessage(category, message), context ?? "");
+  }
+
+  info(category: LogCategory, message: string, context?: LogContext): void {
+    if (!this.shouldLog(category)) return;
+    console.log(this.formatMessage(category, message), context ?? "");
+  }
+
+  warn(category: LogCategory, message: string, context?: LogContext): void {
+    if (!this.shouldLog(category)) return;
+    console.warn(this.formatMessage(category, message), context ?? "");
+  }
+
+  error(category: LogCategory, message: string, error?: unknown, context?: LogContext): void {
+    if (!this.shouldLog(category)) return;
+    console.error(this.formatMessage(category, message), { error, ...context });
+  }
+
+  /** Log purchase flow events */
+  purchase(message: string, context?: LogContext): void {
+    this.debug(LOG_CATEGORY.PURCHASE, message, context);
+  }
+
+  /** Log credits-related events */
+  credits(message: string, context?: LogContext): void {
+    this.debug(LOG_CATEGORY.CREDITS, message, context);
+  }
+
+  /** Log trial-related events */
+  trial(message: string, context?: LogContext): void {
+    this.debug(LOG_CATEGORY.TRIAL, message, context);
+  }
+
+  /** Log RevenueCat SDK events */
+  revenueCat(message: string, context?: LogContext): void {
+    this.debug(LOG_CATEGORY.REVENUECAT, message, context);
+  }
+
+  /** Log feature gate events */
+  featureGate(message: string, context?: LogContext): void {
+    this.debug(LOG_CATEGORY.FEATURE_GATE, message, context);
+  }
+
+  /** Log sync operations */
+  sync(message: string, context?: LogContext): void {
+    this.debug(LOG_CATEGORY.SYNC, message, context);
+  }
+}
+
+/** Singleton logger instance */
+export const Logger = new SubscriptionLogger();

package/src/presentation/hooks/useCredits.ts

@@ -14,6 +14,8 @@ import {
     isCreditsRepositoryConfigured,
 } from "../../infrastructure/repositories/CreditsRepositoryProvider";
 
+declare const __DEV__: boolean;
+
 export const creditsQueryKeys = {
   all: ["credits"] as const,
   user: (userId: string) => ["credits", userId] as const,
@@ -77,7 +79,11 @@ export const useCredits = ({
 
       // Background sync: If mapper detected expired status, sync to Firestore
       if (result.data?.status === "expired") {
-        repository.syncExpiredStatus(userId).catch(() => {});
+        repository.syncExpiredStatus(userId).catch((syncError) => {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.warn("[useCredits] Background sync failed:", syncError);
+          }
+        });
       }
 
       return result.data || null;

package/src/presentation/hooks/useFeatureGate.ts

@@ -173,10 +173,8 @@ export function useFeatureGate(
       authGate,
       creditsGate,
       hasSubscription,
-      hasCredits,
       requiredCredits,
       onShowAuthModal,
-      onShowPaywall,
     ]
   );
 

package/src/presentation/hooks/useSubscriptionSettingsConfig.utils.ts

@@ -5,6 +5,7 @@
 
 import { useMemo } from "react";
 import type { UserCredits } from "../../domain/entities/Credits";
+import { resolveSubscriptionStatus, type PeriodType, type SubscriptionStatusType } from "../../domain/entities/SubscriptionStatus";
 import type { SubscriptionSettingsTranslations } from "../types/SubscriptionSettingsTypes";
 
 export interface CreditsInfo {
@@ -38,42 +39,19 @@ export function useCreditsArray(
 
 /**
  * Calculates subscription status type based on premium, renewal status, and period type
- * @param isPremium - Whether user has premium subscription
- * @param willRenew - Whether subscription will auto-renew (false = canceled)
- * @param expiresAt - Expiration date ISO string (null for lifetime)
- * @param periodType - RevenueCat period type: NORMAL, INTRO, or TRIAL
  */
 export function getSubscriptionStatusType(
   isPremium: boolean,
   willRenew?: boolean,
   expiresAt?: string | null,
-  periodType?: "NORMAL" | "INTRO" | "TRIAL"
-): "active" | "trial" | "trial_canceled" | "canceled" | "expired" | "none" {
-  if (!isPremium) {
-    return "none";
-  }
-
-  // Lifetime subscription (no expiration) - always active
-  if (!expiresAt) {
-    return "active";
-  }
-
-  // Check if expired
-  const now = new Date();
-  const expDate = new Date(expiresAt);
-  if (expDate < now) {
-    return "expired";
-  }
-
-  // Trial period handling
-  if (periodType === "TRIAL") {
-    return willRenew === false ? "trial_canceled" : "trial";
-  }
-
-  // Premium with willRenew=false means subscription is canceled but still active until expiration
-  if (willRenew === false) {
-    return "canceled";
-  }
-
-  return "active";
+  periodType?: PeriodType
+): SubscriptionStatusType {
+  const isExpired = expiresAt ? new Date(expiresAt) < new Date() : false;
+
+  return resolveSubscriptionStatus({
+    isPremium,
+    willRenew,
+    isExpired,
+    periodType,
+  });
 }

package/src/revenuecat/presentation/hooks/usePurchasePackage.ts

@@ -13,7 +13,8 @@ import { creditsQueryKeys } from "../../../presentation/hooks/useCredits";
 
 declare const __DEV__: boolean;
 
-export interface PurchaseResult {
+/** Purchase mutation result - simplified for presentation layer */
+export interface PurchaseMutationResult {
   success: boolean;
   productId: string;
 }
@@ -28,7 +29,7 @@ export const usePurchasePackage = (userId: string | undefined) => {
   const { showSuccess, showError } = useAlert();
 
   return useMutation({
-    mutationFn: async (pkg: PurchasesPackage): Promise<PurchaseResult> => {
+    mutationFn: async (pkg: PurchasesPackage): Promise<PurchaseMutationResult> => {
       if (!userId) {
         throw new Error("User not authenticated");
       }

package/src/utils/index.ts

@@ -10,3 +10,7 @@ export * from "./priceUtils";
 export * from "./tierUtils";
 export * from "./types";
 export * from "./validation";
+
+// Logger (infrastructure utility re-exported for convenience)
+export { Logger, LOG_CATEGORY } from "../infrastructure/utils/Logger";
+export type { LogLevel, LogCategory, LogContext } from "../infrastructure/utils/Logger";