@umituz/react-native-subscription 2.25.1 → 2.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.25.1",
+  "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/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

@@ -18,6 +18,22 @@ export type { SubscriptionStatus, SubscriptionStatusType, PeriodType, StatusReso
 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/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/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";