@umituz/react-native-subscription 2.9.5 → 2.9.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.9.5",
+  "version": "2.9.7",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -67,4 +67,4 @@
     "README.md",
     "LICENSE"
   ]
-}
+}

package/src/index.ts

@@ -250,6 +250,12 @@ export {
   type CreditChecker,
 } from "./utils/creditChecker";
 
+export {
+  createAICreditHelpers,
+  type AICreditHelpersConfig,
+  type AICreditHelpers,
+} from "./utils/aiCreditHelpers";
+
 // =============================================================================
 // REVENUECAT - Errors
 // =============================================================================

package/src/infrastructure/models/UserCreditsDocument.ts

@@ -0,0 +1,14 @@
+
+export interface FirestoreTimestamp {
+    toDate: () => Date;
+}
+
+// Document structure when READING from Firestore
+export interface UserCreditsDocumentRead {
+    textCredits: number;
+    imageCredits: number;
+    purchasedAt?: FirestoreTimestamp;
+    lastUpdatedAt?: FirestoreTimestamp;
+    lastPurchaseAt?: FirestoreTimestamp;
+    processedPurchases?: string[];
+}

package/src/infrastructure/repositories/CreditsRepository.ts

@@ -1,10 +1,9 @@
+
 /**
  * Credits Repository
  *
  * Firestore operations for user credits management.
  * Extends BaseRepository from @umituz/react-native-firebase.
- *
- * Generic and reusable - accepts config from main app.
  */
 
 import {
@@ -12,8 +11,8 @@ import {
   getDoc,
   runTransaction,
   serverTimestamp,
-  type FieldValue,
   type Firestore,
+  type Transaction,
 } from "firebase/firestore";
 import { BaseRepository, getFirestore } from "@umituz/react-native-firebase";
 import type {
@@ -22,20 +21,8 @@ import type {
   CreditsResult,
   DeductCreditsResult,
 } from "../../domain/entities/Credits";
-
-interface FirestoreTimestamp {
-  toDate: () => Date;
-}
-
-// Document structure when READING from Firestore
-interface UserCreditsDocumentRead {
-  textCredits: number;
-  imageCredits: number;
-  purchasedAt?: FirestoreTimestamp;
-  lastUpdatedAt?: FirestoreTimestamp;
-  lastPurchaseAt?: FirestoreTimestamp;
-  processedPurchases?: string[];
-}
+import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
+import { initializeCreditsTransaction } from "../services/CreditsInitializer";
 
 export class CreditsRepository extends BaseRepository {
   private config: CreditsConfig;
@@ -83,8 +70,7 @@ export class CreditsRepository extends BaseRepository {
       return {
         success: false,
         error: {
-          message:
-            error instanceof Error ? error.message : "Failed to get credits",
+          message: error instanceof Error ? error.message : "Failed to get credits",
           code: "FETCH_FAILED",
         },
       };
@@ -105,53 +91,12 @@ export class CreditsRepository extends BaseRepository {
 
     try {
       const creditsRef = this.getCreditsDocRef(db, userId);
-
-      const result = await runTransaction(db, async (transaction) => {
-        const creditsDoc = await transaction.get(creditsRef);
-        const now = serverTimestamp();
-
-        let newTextCredits = this.config.textCreditLimit;
-        let newImageCredits = this.config.imageCreditLimit;
-        let purchasedAt = now;
-        let processedPurchases: string[] = [];
-
-        if (creditsDoc.exists()) {
-          const existing = creditsDoc.data() as UserCreditsDocumentRead;
-          processedPurchases = existing.processedPurchases || [];
-
-          if (purchaseId && processedPurchases.includes(purchaseId)) {
-            return {
-              textCredits: existing.textCredits,
-              imageCredits: existing.imageCredits,
-              alreadyProcessed: true,
-            };
-          }
-
-          newTextCredits =
-            (existing.textCredits || 0) + this.config.textCreditLimit;
-          newImageCredits =
-            (existing.imageCredits || 0) + this.config.imageCreditLimit;
-          // Keep existing purchasedAt if available, otherwise use server timestamp
-          if (existing.purchasedAt) {
-            purchasedAt = existing.purchasedAt as unknown as FieldValue;
-          }
-        }
-
-        if (purchaseId) {
-          processedPurchases = [...processedPurchases, purchaseId].slice(-10);
-        }
-
-        transaction.set(creditsRef, {
-          textCredits: newTextCredits,
-          imageCredits: newImageCredits,
-          purchasedAt,
-          lastUpdatedAt: now,
-          lastPurchaseAt: now,
-          processedPurchases,
-        });
-
-        return { textCredits: newTextCredits, imageCredits: newImageCredits };
-      });
+      const result = await initializeCreditsTransaction(
+        db,
+        creditsRef,
+        this.config,
+        purchaseId
+      );
 
       return {
         success: true,
@@ -166,10 +111,7 @@ export class CreditsRepository extends BaseRepository {
       return {
         success: false,
         error: {
-          message:
-            error instanceof Error
-              ? error.message
-              : "Failed to initialize credits",
+          message: error instanceof Error ? error.message : "Failed to initialize credits",
           code: "INIT_FAILED",
         },
       };
@@ -192,62 +134,35 @@ export class CreditsRepository extends BaseRepository {
       const creditsRef = this.getCreditsDocRef(db, userId);
       const fieldName = creditType === "text" ? "textCredits" : "imageCredits";
 
-      const newCredits = await runTransaction(db, async (transaction) => {
+      const newCredits = await runTransaction(db, async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
-
-        if (!creditsDoc.exists()) {
-          throw new Error("NO_CREDITS");
-        }
+        if (!creditsDoc.exists()) throw new Error("NO_CREDITS");
 
         const currentCredits = creditsDoc.data()[fieldName] as number;
-
-        if (currentCredits <= 0) {
-          throw new Error("CREDITS_EXHAUSTED");
-        }
+        if (currentCredits <= 0) throw new Error("CREDITS_EXHAUSTED");
 
         const updatedCredits = currentCredits - 1;
         transaction.update(creditsRef, {
           [fieldName]: updatedCredits,
           lastUpdatedAt: serverTimestamp(),
         });
-
         return updatedCredits;
       });
 
       return { success: true, remainingCredits: newCredits };
     } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : "Unknown error";
-
-      if (errorMessage === "NO_CREDITS") {
-        return {
-          success: false,
-          error: { message: "No credits found", code: "NO_CREDITS" },
-        };
-      }
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      const code = msg === "NO_CREDITS" || msg === "CREDITS_EXHAUSTED" ? msg : "DEDUCT_FAILED";
+      const message = msg === "NO_CREDITS" ? "No credits found" : msg === "CREDITS_EXHAUSTED" ? "Credits exhausted" : msg;
 
-      if (errorMessage === "CREDITS_EXHAUSTED") {
-        return {
-          success: false,
-          error: { message: "Credits exhausted", code: "CREDITS_EXHAUSTED" },
-        };
-      }
-
-      return {
-        success: false,
-        error: { message: errorMessage, code: "DEDUCT_FAILED" },
-      };
+      return { success: false, error: { message, code } };
     }
   }
 
   async hasCredits(userId: string, creditType: CreditType): Promise<boolean> {
     const result = await this.getCredits(userId);
-    if (!result.success || !result.data) {
-      return false;
-    }
-
-    const credits =
-      creditType === "text" ? result.data.textCredits : result.data.imageCredits;
+    if (!result.success || !result.data) return false;
+    const credits = creditType === "text" ? result.data.textCredits : result.data.imageCredits;
     return credits > 0;
   }
 }

package/src/infrastructure/services/CreditsInitializer.ts

@@ -0,0 +1,67 @@
+
+import {
+    runTransaction,
+    serverTimestamp,
+    type Firestore,
+    type FieldValue,
+    type Transaction,
+    type DocumentReference,
+} from "firebase/firestore";
+import type { CreditsConfig } from "../../domain/entities/Credits";
+import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
+
+interface InitializationResult {
+    textCredits: number;
+    imageCredits: number;
+}
+
+export async function initializeCreditsTransaction(
+    db: Firestore,
+    creditsRef: DocumentReference,
+    config: CreditsConfig,
+    purchaseId?: string
+): Promise<InitializationResult> {
+    return runTransaction(db, async (transaction: Transaction) => {
+        const creditsDoc = await transaction.get(creditsRef);
+        const now = serverTimestamp();
+
+        let newTextCredits = config.textCreditLimit;
+        let newImageCredits = config.imageCreditLimit;
+        let purchasedAt = now;
+        let processedPurchases: string[] = [];
+
+        if (creditsDoc.exists()) {
+            const existing = creditsDoc.data() as UserCreditsDocumentRead;
+            processedPurchases = existing.processedPurchases || [];
+
+            if (purchaseId && processedPurchases.includes(purchaseId)) {
+                return {
+                    textCredits: existing.textCredits,
+                    imageCredits: existing.imageCredits,
+                    alreadyProcessed: true,
+                };
+            }
+
+            newTextCredits = (existing.textCredits || 0) + config.textCreditLimit;
+            newImageCredits = (existing.imageCredits || 0) + config.imageCreditLimit;
+            if (existing.purchasedAt) {
+                purchasedAt = existing.purchasedAt as unknown as FieldValue;
+            }
+        }
+
+        if (purchaseId) {
+            processedPurchases = [...processedPurchases, purchaseId].slice(-10);
+        }
+
+        transaction.set(creditsRef, {
+            textCredits: newTextCredits,
+            imageCredits: newImageCredits,
+            purchasedAt,
+            lastUpdatedAt: now,
+            lastPurchaseAt: now,
+            processedPurchases,
+        });
+
+        return { textCredits: newTextCredits, imageCredits: newImageCredits };
+    });
+}

package/src/utils/aiCreditHelpers.ts

@@ -0,0 +1,114 @@
+/**
+ * AI Credit Helpers
+ *
+ * Common patterns for AI generation apps to handle credits.
+ * Provides ready-to-use functions for credit checking and deduction.
+ *
+ * Usage:
+ *   import { createAICreditHelpers } from '@umituz/react-native-subscription';
+ *
+ *   const helpers = createAICreditHelpers({
+ *     repository,
+ *     imageGenerationTypes: ['future_image', 'santa_transform'],
+ *     onCreditDeducted: (userId) => invalidateCache(userId)
+ *   });
+ */
+
+import type { CreditType } from "../domain/entities/Credits";
+import type { CreditsRepository } from "../infrastructure/repositories/CreditsRepository";
+import { createCreditChecker } from "./creditChecker";
+
+export interface AICreditHelpersConfig {
+  /**
+   * Credits repository instance
+   */
+  repository: CreditsRepository;
+
+  /**
+   * List of operation types that should use "image" credits.
+   * All other types will use "text" credits.
+   * @example ['future_image', 'santa_transform', 'photo_generation']
+   */
+  imageGenerationTypes: string[];
+
+  /**
+   * Optional callback called after successful credit deduction.
+   * Use this to invalidate TanStack Query cache or trigger UI updates.
+   */
+  onCreditDeducted?: (userId: string, creditType: CreditType) => void;
+}
+
+export interface AICreditHelpers {
+  /**
+   * Check if user has credits for a specific generation type
+   * @param userId - User ID
+   * @param generationType - Type of generation (e.g., 'future_image', 'text_summary')
+   * @returns boolean indicating if credits are available
+   */
+  checkCreditsForGeneration: (
+    userId: string | undefined,
+    generationType: string
+  ) => Promise<boolean>;
+
+  /**
+   * Deduct credits after successful generation
+   * @param userId - User ID
+   * @param generationType - Type of generation that was performed
+   */
+  deductCreditsForGeneration: (
+    userId: string | undefined,
+    generationType: string
+  ) => Promise<void>;
+
+  /**
+   * Get credit type for a generation type (useful for UI display)
+   * @param generationType - Type of generation
+   * @returns "image" or "text"
+   */
+  getCreditType: (generationType: string) => CreditType;
+}
+
+/**
+ * Creates AI-specific credit helper functions
+ */
+export function createAICreditHelpers(
+  config: AICreditHelpersConfig
+): AICreditHelpers {
+  const { repository, imageGenerationTypes, onCreditDeducted } = config;
+
+  // Map generation type to credit type
+  const getCreditType = (generationType: string): CreditType => {
+    return imageGenerationTypes.includes(generationType) ? "image" : "text";
+  };
+
+  // Create credit checker with the mapping
+  const checker = createCreditChecker({
+    repository,
+    getCreditType,
+    onCreditDeducted,
+  });
+
+  // Check if credits are available for generation
+  const checkCreditsForGeneration = async (
+    userId: string | undefined,
+    generationType: string
+  ): Promise<boolean> => {
+    const result = await checker.checkCreditsAvailable(userId, generationType);
+    return result.success;
+  };
+
+  // Deduct credits after successful generation
+  const deductCreditsForGeneration = async (
+    userId: string | undefined,
+    generationType: string
+  ): Promise<void> => {
+    const creditType = getCreditType(generationType);
+    await checker.deductCreditsAfterSuccess(userId, creditType);
+  };
+
+  return {
+    checkCreditsForGeneration,
+    deductCreditsForGeneration,
+    getCreditType,
+  };
+}