@umituz/react-native-subscription 2.33.0 → 2.33.1

package/src/domains/subscription/infrastructure/utils/renewal/RenewalDetector.ts

@@ -0,0 +1,78 @@
+import type { CustomerInfo } from "react-native-purchases";
+import type { RenewalState, RenewalDetectionResult } from "./types";
+import { getPackageTier } from "./PackageTierComparator";
+
+export function detectRenewal(
+  state: RenewalState,
+  customerInfo: CustomerInfo,
+  entitlementId: string
+): RenewalDetectionResult {
+  const entitlement = customerInfo.entitlements.active[entitlementId];
+
+  const baseResult: RenewalDetectionResult = {
+    isRenewal: false,
+    isPlanChange: false,
+    isUpgrade: false,
+    isDowngrade: false,
+    productId: null,
+    previousProductId: state.previousProductId,
+    newExpirationDate: null,
+  };
+
+  if (!entitlement) {
+    return baseResult;
+  }
+
+  const newExpirationDate = entitlement.expirationDate;
+  const productId = entitlement.productIdentifier;
+
+  if (!state.previousExpirationDate || !state.previousProductId) {
+    return {
+      ...baseResult,
+      productId,
+      newExpirationDate,
+    };
+  }
+
+  if (!newExpirationDate) {
+    return {
+      ...baseResult,
+      productId,
+      newExpirationDate,
+    };
+  }
+
+  const newExpiration = new Date(newExpirationDate);
+  const previousExpiration = new Date(state.previousExpirationDate);
+  const productChanged = productId !== state.previousProductId;
+  const expirationExtended = newExpiration > previousExpiration;
+
+  if (productChanged) {
+    const oldTier = getPackageTier(state.previousProductId);
+    const newTier = getPackageTier(productId);
+    const isUpgrade = newTier > oldTier;
+    const isDowngrade = newTier < oldTier;
+
+    return {
+      isRenewal: false,
+      isPlanChange: true,
+      isUpgrade,
+      isDowngrade,
+      productId,
+      previousProductId: state.previousProductId,
+      newExpirationDate,
+    };
+  }
+
+  const isRenewal = expirationExtended;
+
+  return {
+    isRenewal,
+    isPlanChange: false,
+    isUpgrade: false,
+    isDowngrade: false,
+    productId,
+    previousProductId: state.previousProductId,
+    newExpirationDate,
+  };
+}

package/src/domains/subscription/infrastructure/utils/renewal/RenewalStateUpdater.ts

@@ -0,0 +1,11 @@
+import type { RenewalState, RenewalDetectionResult } from "./types";
+
+export function updateRenewalState(
+  _state: RenewalState,
+  result: RenewalDetectionResult
+): RenewalState {
+  return {
+    previousExpirationDate: result.newExpirationDate,
+    previousProductId: result.productId,
+  };
+}

package/src/domains/subscription/infrastructure/utils/renewal/index.ts

@@ -0,0 +1,3 @@
+export type { RenewalState, RenewalDetectionResult } from "./types";
+export { detectRenewal } from "./RenewalDetector";
+export { updateRenewalState } from "./RenewalStateUpdater";

package/src/domains/subscription/infrastructure/utils/renewal/types.ts

@@ -0,0 +1,14 @@
+export interface RenewalState {
+  previousExpirationDate: string | null;
+  previousProductId: string | null;
+}
+
+export interface RenewalDetectionResult {
+  isRenewal: boolean;
+  isPlanChange: boolean;
+  isUpgrade: boolean;
+  isDowngrade: boolean;
+  productId: string | null;
+  previousProductId: string | null;
+  newExpirationDate: string | null;
+}

package/src/domains/wallet/index.ts

@@ -64,7 +64,7 @@ export {
 export {
   TransactionRepository,
   createTransactionRepository,
-} from "./infrastructure/repositories/TransactionRepository";
+} from "./infrastructure/repositories/transaction";
 
 // Services
 export {
@@ -73,7 +73,7 @@ export {
   configureProductMetadataService,
   getProductMetadataService,
   resetProductMetadataService,
-} from "./infrastructure/services/ProductMetadataService";
+} from "./infrastructure/services/product-metadata";
 
 // Hooks
 export {

package/src/domains/wallet/infrastructure/repositories/transaction/CollectionBuilder.ts

@@ -0,0 +1,14 @@
+import { buildCollectionRef, type CollectionConfig } from "../../../../../shared/infrastructure/firestore";
+import type { TransactionRepositoryConfig } from "../../../domain/types/transaction.types";
+
+export function getCollectionConfig(config: TransactionRepositoryConfig): CollectionConfig {
+  return {
+    collectionName: config.collectionName,
+    useUserSubcollection: config.useUserSubcollection ?? false,
+  };
+}
+
+export function getCollectionRef(db: any, userId: string, config: TransactionRepositoryConfig) {
+  const collectionConfig = getCollectionConfig(config);
+  return buildCollectionRef(db, userId, collectionConfig);
+}

package/src/domains/wallet/infrastructure/repositories/transaction/TransactionFetcher.ts

@@ -0,0 +1,46 @@
+import {
+  getDocs,
+  query,
+  where,
+  orderBy,
+  limit as firestoreLimit,
+  type QueryConstraint,
+} from "firebase/firestore";
+import type {
+  CreditLog,
+  TransactionRepositoryConfig,
+  TransactionQueryOptions,
+  TransactionResult,
+} from "../../../domain/types/transaction.types";
+import { TransactionMapper } from "../../../domain/mappers/TransactionMapper";
+import { requireFirestore, mapErrorToResult } from "../../../../../shared/infrastructure/firestore";
+import { getCollectionRef } from "./CollectionBuilder";
+
+export async function fetchTransactions(
+  config: TransactionRepositoryConfig,
+  options: TransactionQueryOptions
+): Promise<TransactionResult> {
+  try {
+    const db = requireFirestore();
+    const colRef = getCollectionRef(db, options.userId, config);
+    const constraints: QueryConstraint[] = [];
+
+    if (!config.useUserSubcollection) {
+      constraints.push(where("userId", "==", options.userId));
+    }
+
+    constraints.push(orderBy("createdAt", "desc"));
+    constraints.push(firestoreLimit(options.limit ?? 50));
+
+    const q = query(colRef, ...constraints);
+    const snapshot = await getDocs(q);
+
+    const transactions: CreditLog[] = snapshot.docs.map((docSnap) =>
+      TransactionMapper.toEntity(docSnap, options.userId)
+    );
+
+    return { success: true, data: transactions };
+  } catch (error) {
+    return mapErrorToResult(error);
+  }
+}

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

@@ -0,0 +1,34 @@
+import { BaseRepository } from "@umituz/react-native-firebase";
+import type {
+  CreditLog,
+  TransactionRepositoryConfig,
+  TransactionQueryOptions,
+  TransactionResult,
+  TransactionReason,
+} from "../../../domain/types/transaction.types";
+import { fetchTransactions } from "./TransactionFetcher";
+import { addTransaction as addTransactionOp } from "./TransactionWriter";
+
+export class TransactionRepository extends BaseRepository {
+  private config: TransactionRepositoryConfig;
+
+  constructor(config: TransactionRepositoryConfig) {
+    super(config.collectionName);
+    this.config = config;
+  }
+
+  async getTransactions(
+    options: TransactionQueryOptions
+  ): Promise<TransactionResult> {
+    return fetchTransactions(this.config, options);
+  }
+
+  async addTransaction(
+    userId: string,
+    change: number,
+    reason: TransactionReason,
+    metadata?: Partial<CreditLog>
+  ): Promise<TransactionResult<CreditLog>> {
+    return addTransactionOp(this.config, userId, change, reason, metadata);
+  }
+}

package/src/domains/wallet/infrastructure/repositories/transaction/TransactionWriter.ts

@@ -0,0 +1,43 @@
+import { addDoc, serverTimestamp } from "firebase/firestore";
+import type {
+  CreditLog,
+  TransactionRepositoryConfig,
+  TransactionResult,
+  TransactionReason,
+} from "../../../domain/types/transaction.types";
+import { TransactionMapper } from "../../../domain/mappers/TransactionMapper";
+import { requireFirestore, mapErrorToResult } from "../../../../../shared/infrastructure/firestore";
+import { getCollectionRef } from "./CollectionBuilder";
+
+export async function addTransaction(
+  config: TransactionRepositoryConfig,
+  userId: string,
+  change: number,
+  reason: TransactionReason,
+  metadata?: Partial<CreditLog>
+): Promise<TransactionResult<CreditLog>> {
+  try {
+    const db = requireFirestore();
+    const colRef = getCollectionRef(db, userId, config);
+    const docData = {
+      ...TransactionMapper.toFirestore(userId, change, reason, metadata),
+      createdAt: serverTimestamp(),
+    };
+
+    const docRef = await addDoc(colRef, docData);
+
+    return {
+      success: true,
+      data: {
+        id: docRef.id,
+        userId,
+        change,
+        reason,
+        ...metadata,
+        createdAt: Date.now(),
+      },
+    };
+  } catch (error) {
+    return mapErrorToResult<CreditLog>(error);
+  }
+}

package/src/domains/wallet/infrastructure/repositories/transaction/index.ts

@@ -0,0 +1,10 @@
+import type { TransactionRepositoryConfig } from "../../../domain/types/transaction.types";
+import { TransactionRepository } from "./TransactionRepository";
+
+export { TransactionRepository } from "./TransactionRepository";
+
+export function createTransactionRepository(
+  config: TransactionRepositoryConfig
+): TransactionRepository {
+  return new TransactionRepository(config);
+}

package/src/domains/wallet/infrastructure/services/product-metadata/CacheManager.ts

@@ -0,0 +1,30 @@
+import type { ProductMetadata } from "../../../domain/types/wallet.types";
+
+interface CacheEntry {
+  data: ProductMetadata[];
+  timestamp: number;
+}
+
+const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000;
+
+export class CacheManager {
+  private cache: CacheEntry | null = null;
+
+  isCacheValid(cacheTTL?: number): boolean {
+    if (!this.cache) return false;
+    const ttl = cacheTTL ?? DEFAULT_CACHE_TTL_MS;
+    return Date.now() - this.cache.timestamp < ttl;
+  }
+
+  get(): ProductMetadata[] | null {
+    return this.cache?.data ?? null;
+  }
+
+  set(data: ProductMetadata[]): void {
+    this.cache = { data, timestamp: Date.now() };
+  }
+
+  clear(): void {
+    this.cache = null;
+  }
+}

package/src/domains/wallet/infrastructure/services/product-metadata/FirebaseFetcher.ts

@@ -0,0 +1,17 @@
+import { collection, getDocs, orderBy, query } from "firebase/firestore";
+import { requireFirestore } from "../../../../../shared/infrastructure";
+import type { ProductMetadata } from "../../../domain/types/wallet.types";
+
+export async function fetchProductsFromFirebase(
+  collectionName: string
+): Promise<ProductMetadata[]> {
+  const db = requireFirestore();
+  const colRef = collection(db, collectionName);
+  const q = query(colRef, orderBy("order", "asc"));
+  const snapshot = await getDocs(q);
+
+  return snapshot.docs.map((docSnap) => ({
+    productId: docSnap.id,
+    ...docSnap.data(),
+  })) as ProductMetadata[];
+}

package/src/domains/wallet/infrastructure/services/product-metadata/ProductMetadataService.ts

@@ -0,0 +1,57 @@
+import type {
+  ProductMetadata,
+  ProductMetadataConfig,
+  ProductType,
+} from "../../../domain/types/wallet.types";
+import { CacheManager } from "./CacheManager";
+import { fetchProductsFromFirebase } from "./FirebaseFetcher";
+
+export class ProductMetadataService {
+  private config: ProductMetadataConfig;
+  private cacheManager: CacheManager;
+
+  constructor(config: ProductMetadataConfig) {
+    this.config = config;
+    this.cacheManager = new CacheManager();
+  }
+
+  async getAll(): Promise<ProductMetadata[]> {
+    if (this.cacheManager.isCacheValid(this.config.cacheTTL)) {
+      return this.cacheManager.get()!;
+    }
+
+    try {
+      const data = await fetchProductsFromFirebase(this.config.collectionName);
+      this.cacheManager.set(data);
+      return data;
+    } catch (error) {
+      const cachedData = this.cacheManager.get();
+      if (cachedData) {
+        return cachedData;
+      }
+      throw error;
+    }
+  }
+
+  async getByProductId(productId: string): Promise<ProductMetadata | null> {
+    const all = await this.getAll();
+    return all.find((p) => p.productId === productId) ?? null;
+  }
+
+  async getByType(type: ProductType): Promise<ProductMetadata[]> {
+    const all = await this.getAll();
+    return all.filter((p) => p.type === type);
+  }
+
+  async getCreditsPackages(): Promise<ProductMetadata[]> {
+    return this.getByType("credits");
+  }
+
+  async getSubscriptionPackages(): Promise<ProductMetadata[]> {
+    return this.getByType("subscription");
+  }
+
+  clearCache(): void {
+    this.cacheManager.clear();
+  }
+}

package/src/domains/wallet/infrastructure/services/product-metadata/ServiceManager.ts

@@ -0,0 +1,29 @@
+import type { ProductMetadataConfig } from "../../../domain/types/wallet.types";
+import { ProductMetadataService } from "./ProductMetadataService";
+
+export function createProductMetadataService(
+  config: ProductMetadataConfig
+): ProductMetadataService {
+  return new ProductMetadataService(config);
+}
+
+let defaultService: ProductMetadataService | null = null;
+
+export function configureProductMetadataService(
+  config: ProductMetadataConfig
+): void {
+  defaultService = new ProductMetadataService(config);
+}
+
+export function getProductMetadataService(): ProductMetadataService {
+  if (!defaultService) {
+    throw new Error(
+      "ProductMetadataService not configured. Call configureProductMetadataService first."
+    );
+  }
+  return defaultService;
+}
+
+export function resetProductMetadataService(): void {
+  defaultService = null;
+}

package/src/domains/wallet/infrastructure/services/product-metadata/index.ts

@@ -0,0 +1,7 @@
+export { ProductMetadataService } from "./ProductMetadataService";
+export {
+  createProductMetadataService,
+  configureProductMetadataService,
+  getProductMetadataService,
+  resetProductMetadataService,
+} from "./ServiceManager";

package/src/domains/wallet/presentation/hooks/useProductMetadata.ts

@@ -5,7 +5,7 @@ import type {
   ProductMetadataConfig,
   ProductType,
 } from "../../domain/types/wallet.types";
-import { ProductMetadataService } from "../../infrastructure/services/ProductMetadataService";
+import { ProductMetadataService } from "../../infrastructure/services/product-metadata";
 
 export const productMetadataQueryKeys = {
   all: ["productMetadata"] as const,

package/src/domains/wallet/presentation/hooks/useTransactionHistory.ts

@@ -5,7 +5,7 @@ import type {
   CreditLog,
   TransactionRepositoryConfig,
 } from "../../domain/types/transaction.types";
-import { TransactionRepository } from "../../infrastructure/repositories/TransactionRepository";
+import { TransactionRepository } from "../../infrastructure/repositories/transaction";
 
 export const transactionQueryKeys = {
   all: ["transactions"] as const,

package/src/index.ts

@@ -32,7 +32,7 @@ export {
 export type { Result, Success, Failure } from "./shared/utils/Result";
 
 // Infrastructure Layer (Services & Repositories)
-export { initializeSubscription, type SubscriptionInitConfig, type CreditPackageConfig } from "./domains/subscription/application/SubscriptionInitializer";
+export { initializeSubscription, type SubscriptionInitConfig, type CreditPackageConfig } from "./domains/subscription/application/initializer";
 export { 
   getDeviceId,
   checkTrialEligibility,
@@ -53,7 +53,7 @@ export {
 // Presentation Layer - Hooks
 export { useAuthAwarePurchase } from "./domains/subscription/presentation/useAuthAwarePurchase";
 export { useCredits } from "./domains/credits/presentation/useCredits";
-export { useDeductCredit } from "./domains/credits/presentation/useDeductCredit";
+export { useDeductCredit } from "./domains/credits/presentation/deduct-credit";
 export { useFeatureGate } from "./domains/subscription/presentation/useFeatureGate";
 export { usePaywallVisibility, paywallControl } from "./domains/subscription/presentation/usePaywallVisibility";
 export { usePremium } from "./domains/subscription/presentation/usePremium";

package/src/init/createSubscriptionInitModule.ts

@@ -1,5 +1,5 @@
 import type { InitModule } from '@umituz/react-native-design-system';
-import { initializeSubscription, type SubscriptionInitConfig } from '../domains/subscription/application/SubscriptionInitializer';
+import { initializeSubscription, type SubscriptionInitConfig } from '../domains/subscription/application/initializer';
 
 export interface SubscriptionInitModuleConfig extends Omit<SubscriptionInitConfig, 'apiKey'> {
   getApiKey: () => string | undefined;

package/src/domains/credits/presentation/useDeductCredit.ts

@@ -1,110 +0,0 @@
-/**
- * useDeductCredit Hook
- * TanStack Query mutation hook for deducting credits.
- */
-
-import { useCallback } from "react";
-import { useMutation, useQueryClient } from "@umituz/react-native-design-system";
-import type { UserCredits } from "../core/Credits";
-import { getCreditsRepository } from "../infrastructure/CreditsRepositoryManager";
-import { creditsQueryKeys } from "./creditsQueryKeys";
-import { calculateRemaining } from "../../../shared/utils/numberUtils";
-
-import { timezoneService } from "@umituz/react-native-design-system";
-
-export interface UseDeductCreditParams {
-  userId: string | undefined;
-  onCreditsExhausted?: () => void;
-}
-
-export interface UseDeductCreditResult {
-  /** Check if user has enough credits (server-side validation) */
-  checkCredits: (cost?: number) => Promise<boolean>;
-  deductCredit: (cost?: number) => Promise<boolean>;
-  deductCredits: (cost: number) => Promise<boolean>;
-  isDeducting: boolean;
-}
-
-export const useDeductCredit = ({
-  userId,
-  onCreditsExhausted,
-}: UseDeductCreditParams): UseDeductCreditResult => {
-  const repository = getCreditsRepository();
-  const queryClient = useQueryClient();
-
-  const mutation = useMutation({
-    mutationFn: async (cost: number) => {
-      if (!userId) throw new Error("User not authenticated");
-      return repository.deductCredit(userId, cost);
-    },
-    onMutate: async (cost: number) => {
-      if (!userId) return { previousCredits: null, skippedOptimistic: true, capturedUserId: null };
-
-      // Capture userId at mutation start to prevent cross-user contamination
-      const capturedUserId = userId;
-
-      await queryClient.cancelQueries({ queryKey: creditsQueryKeys.user(capturedUserId) });
-      const previousCredits = queryClient.getQueryData<UserCredits>(creditsQueryKeys.user(capturedUserId));
-
-      if (!previousCredits) {
-        return { previousCredits: null as UserCredits | null, skippedOptimistic: true, capturedUserId };
-      }
-
-      // Calculate new credits using utility
-      const newCredits = calculateRemaining(previousCredits.credits, cost);
-
-      queryClient.setQueryData<UserCredits | null>(creditsQueryKeys.user(capturedUserId), (old) => {
-        if (!old) return old;
-        return {
-          ...old,
-          credits: newCredits,
-          lastUpdatedAt: timezoneService.getNow()
-        };
-      });
-
-      return {
-        previousCredits,
-        skippedOptimistic: false,
-        wasInsufficient: previousCredits.credits < cost,
-        capturedUserId
-      };
-    },
-    onError: (_err, _cost, mutationData) => {
-      // Always restore previous credits on error to prevent UI desync
-      // Use captured userId to prevent rollback on wrong user
-      if (mutationData?.capturedUserId && mutationData?.previousCredits && !mutationData.skippedOptimistic) {
-         queryClient.setQueryData(creditsQueryKeys.user(mutationData.capturedUserId), mutationData.previousCredits);
-      }
-    },
-    onSuccess: (_data, _cost, mutationData) => {
-      const targetUserId = mutationData?.capturedUserId ?? userId;
-      if (targetUserId) {
-        queryClient.invalidateQueries({ queryKey: creditsQueryKeys.user(targetUserId) });
-      }
-    },
-  });
-
-  const deductCredit = useCallback(async (cost: number = 1): Promise<boolean> => {
-    try {
-      const res = await mutation.mutateAsync(cost);
-      if (!res.success) {
-        if (res.error?.code === "CREDITS_EXHAUSTED") onCreditsExhausted?.();
-        return false;
-      }
-      return true;
-    } catch {
-      return false;
-    }
-  }, [mutation, onCreditsExhausted]);
-
-  const deductCredits = useCallback(async (cost: number): Promise<boolean> => {
-    return await deductCredit(cost);
-  }, [deductCredit]);
-
-  const checkCredits = useCallback(async (cost: number = 1): Promise<boolean> => {
-    if (!userId) return false;
-    return repository.hasCredits(userId, cost);
-  }, [userId, repository]);
-
-  return { checkCredits, deductCredit, deductCredits, isDeducting: mutation.isPending };
-};