@umituz/react-native-subscription 2.27.115 → 2.27.116

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.115",
+  "version": "2.27.116",
   "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/domains/credits/infrastructure/CreditsRepository.ts

@@ -3,8 +3,8 @@
  * Optimized to use Design Patterns: Command, Observer, and Strategy.
  */
 
-import { doc, getDoc, type Firestore } from "firebase/firestore";
-import { BaseRepository, getFirestore } from "@umituz/react-native-firebase";
+import { getDoc, setDoc, type Firestore } from "firebase/firestore";
+import { BaseRepository } from "@umituz/react-native-firebase";
 import type { CreditsConfig, CreditsResult, DeductCreditsResult } from "../core/Credits";
 import type { UserCreditsDocumentRead, PurchaseSource } from "../core/UserCreditsDocument";
 import { initializeCreditsTransaction } from "../application/CreditsInitializer";
@@ -13,7 +13,7 @@ import type { RevenueCatData } from "../../subscription/core/RevenueCatData";
 import { DeductCreditsCommand } from "../application/DeductCreditsCommand";
 import { CreditLimitCalculator } from "../application/CreditLimitCalculator";
 import { PURCHASE_TYPE, type PurchaseType } from "../../subscription/core/SubscriptionConstants";
-import { setDoc } from "firebase/firestore";
+import { requireFirestore, buildDocRef, type CollectionConfig } from "../../../shared/infrastructure/firestore";
 
 export class CreditsRepository extends BaseRepository {
   private deductCommand: DeductCreditsCommand;
@@ -23,19 +23,22 @@ export class CreditsRepository extends BaseRepository {
     this.deductCommand = new DeductCreditsCommand((db, uid) => this.getRef(db, uid));
   }
 
+  private getCollectionConfig(): CollectionConfig {
+    return {
+      collectionName: "credits",
+      useUserSubcollection: this.config.useUserSubcollection,
+    };
+  }
+
   private getRef(db: Firestore, userId: string) {
-    return this.config.useUserSubcollection
-      ? doc(db, "users", userId, "credits", "balance")
-      : doc(db, this.config.collectionName, userId);
+    const config = this.getCollectionConfig();
+    return buildDocRef(db, userId, "balance", config);
   }
 
   async getCredits(userId: string): Promise<CreditsResult> {
-    const db = getFirestore();
-    if (!db) {
-      throw new Error("Firestore instance is not available");
-    }
-
+    const db = requireFirestore();
     const snap = await getDoc(this.getRef(db, userId));
+
     if (!snap.exists()) {
       return { success: true, data: null, error: null };
     }
@@ -52,11 +55,7 @@ export class CreditsRepository extends BaseRepository {
     revenueCatData: RevenueCatData,
     type: PurchaseType = PURCHASE_TYPE.INITIAL
   ): Promise<CreditsResult> {
-    const db = getFirestore();
-    if (!db) {
-      throw new Error("Firestore instance is not available");
-    }
-
+    const db = requireFirestore();
     const creditLimit = CreditLimitCalculator.calculate(productId, this.config);
     const cfg = { ...this.config, creditLimit };
 
@@ -98,9 +97,7 @@ export class CreditsRepository extends BaseRepository {
   }
 
   async syncExpiredStatus(userId: string): Promise<void> {
-    const db = getFirestore();
-    if (!db) throw new Error("Firestore instance is not available");
-
+    const db = requireFirestore();
     const ref = this.getRef(db, userId);
     await setDoc(ref, {
       isPremium: false,

package/src/domains/credits/utils/creditCalculations.ts

@@ -1,33 +1,28 @@
 /**
  * Credit Calculation Utilities
  * Centralized logic for credit mathematical operations
+ * Uses shared number utilities for consistency
  */
 
+import { calculateCreditPercentage as calcPct, canAfford as canAffordCheck, calculateRemaining } from "../../../shared/utils/numberUtils";
+
 export const calculateCreditPercentage = (
   currentCredits: number | null | undefined,
   creditLimit: number
 ): number => {
-  if (currentCredits === null || currentCredits === undefined || creditLimit <= 0) {
-    return 0;
-  }
-  
-  const percent = Math.round((currentCredits / creditLimit) * 100);
-  return Math.min(Math.max(percent, 0), 100); // Clamp between 0-100
+  return calcPct(currentCredits, creditLimit);
 };
 
 export const canAffordCost = (
   currentCredits: number | null | undefined,
   cost: number
 ): boolean => {
-  if (currentCredits === null || currentCredits === undefined) {
-    return false;
-  }
-  return currentCredits >= cost;
+  return canAffordCheck(currentCredits, cost);
 };
 
 export const calculateRemainingCredits = (
   currentCredits: number,
   cost: number
 ): number => {
-  return Math.max(0, currentCredits - cost);
+  return calculateRemaining(currentCredits, cost);
 };

package/src/domains/wallet/infrastructure/repositories/TransactionRepository.ts

@@ -6,7 +6,6 @@
  */
 
 import {
-    collection,
     getDocs,
     addDoc,
     query,
@@ -14,10 +13,9 @@ import {
     orderBy,
     limit as firestoreLimit,
     serverTimestamp,
-    type Firestore,
     type QueryConstraint,
 } from "firebase/firestore";
-import { BaseRepository, getFirestore } from "@umituz/react-native-firebase";
+import { BaseRepository } from "@umituz/react-native-firebase";
 import type {
   CreditLog,
   TransactionRepositoryConfig,
@@ -26,6 +24,7 @@ import type {
   TransactionReason,
 } from "../../domain/types/transaction.types";
 import { TransactionMapper } from "../../domain/mappers/TransactionMapper";
+import { requireFirestore, buildCollectionRef, type CollectionConfig, mapErrorToResult } from "../../../../shared/infrastructure/firestore";
 
 export class TransactionRepository extends BaseRepository {
   private config: TransactionRepositoryConfig;
@@ -35,25 +34,23 @@ export class TransactionRepository extends BaseRepository {
     this.config = config;
   }
 
-  private getCollectionRef(db: Firestore, userId: string) {
-    if (this.config.useUserSubcollection) {
-      return collection(db, "users", userId, this.config.collectionName);
-    }
-    return collection(db, this.config.collectionName);
+  private getCollectionConfig(): CollectionConfig {
+    return {
+      collectionName: this.config.collectionName,
+      useUserSubcollection: this.config.useUserSubcollection ?? false,
+    };
+  }
+
+  private getCollectionRef(db: any, userId: string) {
+    const config = this.getCollectionConfig();
+    return buildCollectionRef(db, userId, config);
   }
 
   async getTransactions(
     options: TransactionQueryOptions
   ): Promise<TransactionResult> {
-    const db = getFirestore();
-    if (!db) {
-      return {
-        success: false,
-        error: { message: "Database not available", code: "DB_NOT_AVAILABLE" },
-      };
-    }
-
     try {
+      const db = requireFirestore();
       const colRef = this.getCollectionRef(db, options.userId);
       const constraints: QueryConstraint[] = [];
 
@@ -67,20 +64,13 @@ export class TransactionRepository extends BaseRepository {
       const q = query(colRef, ...constraints);
       const snapshot = await getDocs(q);
 
-      const transactions: CreditLog[] = snapshot.docs.map((docSnap) => 
+      const transactions: CreditLog[] = snapshot.docs.map((docSnap) =>
         TransactionMapper.toEntity(docSnap, options.userId)
       );
 
       return { success: true, data: transactions };
     } catch (error) {
-      return {
-        success: false,
-        error: {
-          message:
-            error instanceof Error ? error.message : "Failed to get logs",
-          code: "FETCH_FAILED",
-        },
-      };
+      return mapErrorToResult(error);
     }
   }
 
@@ -90,15 +80,8 @@ export class TransactionRepository extends BaseRepository {
     reason: TransactionReason,
     metadata?: Partial<CreditLog>
   ): Promise<TransactionResult<CreditLog>> {
-    const db = getFirestore();
-    if (!db) {
-      return {
-        success: false,
-        error: { message: "Database not available", code: "DB_NOT_AVAILABLE" },
-      };
-    }
-
     try {
+      const db = requireFirestore();
       const colRef = this.getCollectionRef(db, userId);
       const docData = {
         ...TransactionMapper.toFirestore(userId, change, reason, metadata),
@@ -119,14 +102,7 @@ export class TransactionRepository extends BaseRepository {
         },
       };
     } catch (error) {
-      return {
-        success: false,
-        error: {
-          message:
-            error instanceof Error ? error.message : "Failed to add log",
-          code: "ADD_FAILED",
-        },
-      };
+      return mapErrorToResult<CreditLog>(error);
     }
   }
 }

package/src/domains/wallet/infrastructure/services/ProductMetadataService.ts

@@ -6,7 +6,7 @@
  */
 
 import { collection, getDocs, orderBy, query } from "firebase/firestore";
-import { getFirestore } from "@umituz/react-native-firebase";
+import { requireFirestore } from "../../../../shared/infrastructure";
 import type {
   ProductMetadata,
   ProductMetadataConfig,
@@ -35,11 +35,7 @@ export class ProductMetadataService {
   }
 
   private async fetchFromFirebase(): Promise<ProductMetadata[]> {
-    const db = getFirestore();
-    if (!db) {
-      throw new Error("Firestore not initialized");
-    }
-
+    const db = requireFirestore();
     const colRef = collection(db, this.config.collectionName);
     const q = query(colRef, orderBy("order", "asc"));
     const snapshot = await getDocs(q);

package/src/shared/infrastructure/firestore/collectionUtils.ts

@@ -0,0 +1,67 @@
+/**
+ * Firestore Collection Utilities
+ * Shared utilities for building Firestore collection and document references
+ */
+
+import {
+  collection,
+  doc,
+  type CollectionReference,
+  type DocumentReference,
+  type Firestore,
+} from "firebase/firestore";
+import { getFirestore } from "@umituz/react-native-firebase";
+
+export interface CollectionConfig {
+  collectionName: string;
+  useUserSubcollection: boolean;
+}
+
+/**
+ * Build a collection reference based on configuration
+ * Supports both root collections and user subcollections
+ */
+export function buildCollectionRef(
+  db: Firestore,
+  userId: string,
+  config: CollectionConfig
+): CollectionReference {
+  if (config.useUserSubcollection) {
+    return collection(db, "users", userId, config.collectionName);
+  }
+  return collection(db, config.collectionName);
+}
+
+/**
+ * Build a document reference based on configuration
+ * Supports both root collections and user subcollections
+ */
+export function buildDocRef(
+  db: Firestore,
+  userId: string,
+  docId: string,
+  config: CollectionConfig
+): DocumentReference {
+  if (config.useUserSubcollection) {
+    return doc(db, "users", userId, config.collectionName, docId);
+  }
+  return doc(db, config.collectionName, docId);
+}
+
+/**
+ * Get Firestore instance or throw error
+ */
+export function requireFirestore(): Firestore {
+  const db = getFirestore();
+  if (!db) {
+    throw new Error("Firestore instance is not available");
+  }
+  return db;
+}
+
+/**
+ * Safe check for Firestore availability
+ */
+export function isFirestoreAvailable(): boolean {
+  return getFirestore() !== null;
+}

package/src/shared/infrastructure/firestore/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Firestore Infrastructure Utilities
+ */
+
+export * from "./collectionUtils";
+export * from "./resultUtils";

package/src/shared/infrastructure/firestore/resultUtils.ts

@@ -0,0 +1,68 @@
+/**
+ * Result Utilities
+ * Shared helpers for working with Result pattern
+ */
+
+import type { Result } from "../../utils/Result";
+import { failure, success } from "../../utils/Result";
+
+export interface ApiError {
+  message: string;
+  code: string;
+}
+
+/**
+ * Create a standard error result
+ */
+export function createErrorResult(
+  message: string,
+  code: string = "UNKNOWN_ERROR"
+): Result<never, ApiError> {
+  return failure({ message, code });
+}
+
+/**
+ * Create a database unavailable error result
+ */
+export function createDbUnavailableResult<T>(): Result<T, ApiError> {
+  return createErrorResult("Database not available", "DB_NOT_AVAILABLE");
+}
+
+/**
+ * Map Error to ApiError result
+ */
+export function mapErrorToResult<T>(error: unknown): Result<T, ApiError> {
+  const message = error instanceof Error ? error.message : "An unknown error occurred";
+  const code = error instanceof Error && "code" in error ? String(error.code) : "UNKNOWN_ERROR";
+  return createErrorResult(message, code);
+}
+
+/**
+ * Execute async function and return Result
+ */
+export async function executeAsResult<T>(
+  fn: () => Promise<T>
+): Promise<Result<T, ApiError>> {
+  try {
+    const data = await fn();
+    return success(data);
+  } catch (error) {
+    return mapErrorToResult<T>(error);
+  }
+}
+
+/**
+ * Validate database availability before executing
+ */
+export async function withDbCheck<T>(
+  fn: (db: any) => Promise<T>
+): Promise<Result<T, ApiError>> {
+  const { requireFirestore } = require("./collectionUtils");
+
+  try {
+    const db = requireFirestore();
+    return await executeAsResult(() => fn(db));
+  } catch (error) {
+    return mapErrorToResult<T>(error);
+  }
+}

package/src/shared/infrastructure/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared Infrastructure
+ */
+
+export * from "./SubscriptionEventBus";
+export * from "./firestore";

package/src/shared/presentation/hooks/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared Presentation Hooks
+ */
+
+export * from "./useAsyncState";
+export * from "./useServiceCall";

package/src/shared/presentation/hooks/useAsyncState.ts

@@ -0,0 +1,72 @@
+/**
+ * useAsyncState Hook
+ * Shared hook for managing async operation states
+ */
+
+import { useState, useCallback } from "react";
+
+export type AsyncStatus = "idle" | "loading" | "success" | "error";
+
+export interface AsyncState<T> {
+  data: T | null;
+  status: AsyncStatus;
+  error: Error | null;
+}
+
+export interface UseAsyncStateOptions<T> {
+  initialData?: T | null;
+  onSuccess?: (data: T) => void;
+  onError?: (error: Error) => void;
+}
+
+export interface UseAsyncStateReturn<T> {
+  data: T | null;
+  status: AsyncStatus;
+  error: Error | null;
+  isLoading: boolean;
+  isSuccess: boolean;
+  isError: boolean;
+  isIdle: boolean;
+  setData: (data: T | null) => void;
+  setError: (error: Error | null) => void;
+  reset: () => void;
+}
+
+export function useAsyncState<T>(
+  options: UseAsyncStateOptions<T> = {}
+): UseAsyncStateReturn<T> {
+  const { initialData = null, onSuccess, onError } = options;
+
+  const [state, setState] = useState<AsyncState<T>>({
+    data: initialData,
+    status: initialData ? "success" : "idle",
+    error: null,
+  });
+
+  const setData = useCallback((data: T | null) => {
+    setState({ data, status: data ? "success" : "idle", error: null });
+    if (data) onSuccess?.(data);
+  }, [onSuccess]);
+
+  const setError = useCallback((error: Error | null) => {
+    setState((prev) => ({ ...prev, status: "error", error }));
+    if (error) onError?.(error);
+  }, [onError]);
+
+  const reset = useCallback(() => {
+    setState({ data: initialData, status: initialData ? "success" : "idle", error: null });
+  }, [initialData]);
+
+  return {
+    data: state.data,
+    status: state.status,
+    error: state.error,
+    isLoading: state.status === "loading",
+    isSuccess: state.status === "success",
+    isError: state.status === "error",
+    isIdle: state.status === "idle",
+    setData,
+    setError,
+    reset,
+  };
+}

package/src/shared/presentation/hooks/useServiceCall.ts

@@ -0,0 +1,66 @@
+/**
+ * useServiceCall Hook
+ * Shared hook for handling service calls with loading, error, and success states
+ */
+
+import { useState, useCallback } from "react";
+
+export interface ServiceCallState<T> {
+  data: T | null;
+  isLoading: boolean;
+  error: Error | null;
+}
+
+export interface UseServiceCallOptions<T> {
+  onSuccess?: (data: T) => void;
+  onError?: (error: Error) => void;
+  onComplete?: () => void;
+}
+
+export interface ServiceCallResult<T> {
+  data: T | null;
+  isLoading: boolean;
+  error: Error | null;
+  execute: () => Promise<void>;
+  reset: () => void;
+}
+
+export function useServiceCall<T>(
+  serviceFn: () => Promise<T>,
+  options: UseServiceCallOptions<T> = {}
+): ServiceCallResult<T> {
+  const { onSuccess, onError, onComplete } = options;
+  const [state, setState] = useState<ServiceCallState<T>>({
+    data: null,
+    isLoading: false,
+    error: null,
+  });
+
+  const execute = useCallback(async () => {
+    setState({ data: null, isLoading: true, error: null });
+
+    try {
+      const data = await serviceFn();
+      setState({ data, isLoading: false, error: null });
+      onSuccess?.(data);
+    } catch (error) {
+      const errorObj = error instanceof Error ? error : new Error("Service call failed");
+      setState({ data: null, isLoading: false, error: errorObj });
+      onError?.(errorObj);
+    } finally {
+      onComplete?.();
+    }
+  }, [serviceFn, onSuccess, onError, onComplete]);
+
+  const reset = useCallback(() => {
+    setState({ data: null, isLoading: false, error: null });
+  }, []);
+
+  return {
+    data: state.data,
+    isLoading: state.isLoading,
+    error: state.error,
+    execute,
+    reset,
+  };
+}

package/src/shared/types/CommonTypes.ts

@@ -3,6 +3,8 @@
  * Shared types used across multiple domains
  */
 
+import type { Platform as SubscriptionPlatform } from "../../domains/subscription/core/SubscriptionConstants";
+
 /**
  * Purchase result from any purchase operation
  */
@@ -57,9 +59,12 @@ export interface TransactionMetadata {
 /**
  * Platform information
  */
-export type Platform = 'ios' | 'android';
+export type Platform = SubscriptionPlatform;
 
 /**
  * Purchase source tracking
  */
 export type PurchaseSource = 'settings' | 'paywall' | 'upgrade_prompt' | 'auto-execution' | 'manual';
+
+// Re-export from SubscriptionConstants to maintain compatibility
+export { PLATFORM, PURCHASE_SOURCE, type Platform as SubscriptionPlatformType, type PurchaseSource as PurchaseSourceType } from "../../domains/subscription/core/SubscriptionConstants";

package/src/shared/types/ReactTypes.ts

@@ -0,0 +1,80 @@
+/**
+ * Shared React Types
+ * Common type definitions for React components and hooks
+ */
+
+export type VoidCallback = () => void;
+export type AsyncCallback = () => Promise<void> | Promise<void>;
+
+export type EventHandler<T = void> = (event: T) => void;
+export type AsyncEventHandler<T = void> = (event: T) => Promise<void>;
+
+export interface LoadingState {
+  isLoading: boolean;
+  isRefreshing: boolean;
+}
+
+export interface ErrorState {
+  error: Error | null;
+  hasError: boolean;
+}
+
+export interface PaginationState {
+  page: number;
+  perPage: number;
+  total: number;
+  hasMore: boolean;
+}
+
+export interface ScreenProps<T = unknown> {
+  route: {
+    params?: T;
+  };
+  navigation: any;
+}
+
+export type ButtonProps = {
+  onPress: EventHandler | AsyncEventHandler;
+  disabled?: boolean;
+  loading?: boolean;
+};
+
+export interface SelectableItem {
+  id: string;
+  selected: boolean;
+}
+
+export interface FormFieldProps<T> {
+  value: T;
+  onChange: (value: T) => void;
+  error?: string;
+  label?: string;
+  placeholder?: string;
+  disabled?: boolean;
+}
+
+export interface ListItemProps<T> {
+  item: T;
+  index: number;
+  onPress?: (item: T, index: number) => void;
+  onLongPress?: (item: T, index: number) => void;
+}
+
+export interface SearchState {
+  query: string;
+  results: unknown[];
+  isSearching: boolean;
+}
+
+export interface TabItem {
+  id: string;
+  title: string;
+  icon?: string;
+  badge?: number | string;
+}
+
+export interface ModalProps {
+  visible: boolean;
+  onClose: () => void;
+  title?: string;
+}