vibefast-cli 0.5.0 → 0.5.1

package/recipes/payments/apps/native/src/features/payments/services/revenuecat-adapter.ts

@@ -0,0 +1,407 @@
+import { Platform } from 'react-native';
+import Purchases, {
+  LOG_LEVEL,
+  type PurchasesOffering,
+  type PurchasesPackage,
+} from 'react-native-purchases';
+
+import { ConfigService } from '@/core/config';
+import * as Logger from '@/core/logging';
+import type {
+  PaymentService,
+  ProductOffering,
+} from '@/core/payments/payment-service';
+
+// Ensure a log handler is registered ASAP to avoid
+// "TypeError: customLogHandler is not a function" on Android Hermes
+try {
+  // If a handler is already set later via configure, this will be overwritten.
+  Purchases.setLogHandler((logLevel, message) => {
+    switch (logLevel) {
+      case LOG_LEVEL.DEBUG:
+        // console.debug(`[RevenueCat] ${message}`);
+        break;
+      case LOG_LEVEL.INFO:
+        // console.info(`[RevenueCat] ${message}`);
+        break;
+      case LOG_LEVEL.WARN:
+        // console.warn(`[RevenueCat] ${message}`);
+        break;
+      case LOG_LEVEL.ERROR:
+        // console.error(`[RevenueCat] ${message}`);
+        break;
+      default:
+      // console.log(`[RevenueCat] ${message}`);
+    }
+  });
+} catch {
+  // best-effort: ignore if native module isn't ready yet
+}
+
+/**
+ * RevenueCat adapter service implementing the PaymentService interface
+ */
+export class RevenueCatAdapter implements PaymentService {
+  private static isInitialized = false;
+
+  /**
+   * Initialize the RevenueCat SDK
+   * Should be called once during app startup
+   */
+  static async initialize(): Promise<void> {
+    if (RevenueCatAdapter.isInitialized) {
+      Logger.info('[RevenueCatAdapter] SDK already initialized, skipping');
+      return;
+    }
+
+    try {
+      // Check if RevenueCat is already configured (Fast Refresh protection)
+      try {
+        await Purchases.getCustomerInfo();
+        Logger.info(
+          '[RevenueCatAdapter] RevenueCat already configured from previous session',
+        );
+        RevenueCatAdapter.isInitialized = true;
+        return;
+      } catch {
+        // Not configured yet, proceed with configuration
+        Logger.debug(
+          '[RevenueCatAdapter] RevenueCat not configured, proceeding with initialization',
+        );
+      }
+
+      // Get the appropriate API key based on platform
+      const apiKey = Platform.select({
+        ios: ConfigService.getRevenueCatApiKeyApple(),
+        android: ConfigService.getRevenueCatApiKeyGoogle(),
+      });
+
+      if (!apiKey) {
+        Logger.warn(
+          `[RevenueCatAdapter] No API key found for platform: ${Platform.OS}`,
+        );
+        return;
+      }
+
+      // Set debug logs level (only in development)
+      if (ConfigService.getAppEnv() !== 'production') {
+        Purchases.setLogLevel(LOG_LEVEL.DEBUG);
+      }
+
+      // Configure and initialize the SDK
+      await Purchases.configure({ apiKey });
+
+      RevenueCatAdapter.isInitialized = true;
+      Logger.info('[RevenueCatAdapter] SDK initialized successfully');
+    } catch (error) {
+      Logger.error(
+        '[RevenueCatAdapter] Failed to initialize SDK: ' + String(error),
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Check if the SDK is initialized
+   */
+  static getIsInitialized(): boolean {
+    return RevenueCatAdapter.isInitialized;
+  }
+
+  /**
+   * Fetch product offerings from RevenueCat
+   */
+  async fetchProductOfferings(
+    _configType: 'local' | 'remote',
+  ): Promise<ProductOffering[]> {
+    this.ensureInitialized();
+
+    try {
+      const offerings = await Purchases.getOfferings();
+      Logger.debug('[RevenueCatAdapter] Offerings retrieved');
+
+      const productOfferings: ProductOffering[] = [];
+
+      // Process current offering
+      if (offerings.current) {
+        const currentOffering = offerings.current;
+
+        // Convert packages to ProductOffering format
+        Object.values(currentOffering.availablePackages).forEach(
+          (pkg: PurchasesPackage) => {
+            productOfferings.push({
+              id: pkg.identifier,
+              priceString: pkg.product.priceString,
+            });
+          },
+        );
+      }
+
+      // Process all offerings if needed
+      Object.values(offerings.all).forEach((offering: PurchasesOffering) => {
+        Object.values(offering.availablePackages).forEach(
+          (pkg: PurchasesPackage) => {
+            // Avoid duplicates
+            if (!productOfferings.find((p) => p.id === pkg.identifier)) {
+              productOfferings.push({
+                id: pkg.identifier,
+                priceString: pkg.product.priceString,
+              });
+            }
+          },
+        );
+      });
+
+      return productOfferings;
+    } catch (error) {
+      Logger.error(
+        '[RevenueCatAdapter] Failed to fetch offerings: ' + String(error),
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Purchase a product
+   */
+  async purchaseProduct(
+    productId: string,
+    offeringIdentifier?: string,
+    onConsumablePurchase?: (details: {
+      productId: string;
+      quantity: number;
+    }) => Promise<void>,
+  ): Promise<{ success: boolean; error?: string; customerInfo?: any }> {
+    this.ensureInitialized();
+
+    try {
+      // Get offerings to find the package
+      const offerings = await Purchases.getOfferings();
+      let packageToPurchase: PurchasesPackage | null = null;
+
+      // Find the package by productId
+      if (offeringIdentifier && offerings.all[offeringIdentifier]) {
+        packageToPurchase =
+          offerings.all[offeringIdentifier].availablePackages.find(
+            (pkg) => pkg.identifier === productId,
+          ) || null;
+      } else if (offerings.current) {
+        packageToPurchase =
+          offerings.current.availablePackages.find(
+            (pkg) => pkg.identifier === productId,
+          ) || null;
+      }
+
+      if (!packageToPurchase) {
+        return {
+          success: false,
+          error: `Package with ID ${productId} not found`,
+        };
+      }
+
+      const { customerInfo } =
+        await Purchases.purchasePackage(packageToPurchase);
+      Logger.info(`[RevenueCatAdapter] Purchase successful: ${productId}`);
+
+      // Check if this is a consumable product and handle it
+      if (onConsumablePurchase && this.isConsumableProduct(productId)) {
+        const quantity = this.getConsumableQuantity(productId);
+        try {
+          await onConsumablePurchase({ productId, quantity });
+          Logger.info(
+            `[RevenueCatAdapter] Consumable purchase recorded: ${productId} (${quantity} credits)`,
+          );
+        } catch (error) {
+          Logger.error(
+            `[RevenueCatAdapter] Failed to record consumable purchase: ${String(error)}`,
+          );
+          // Continue with successful purchase response even if backend recording fails
+        }
+      }
+
+      return {
+        success: true,
+        customerInfo,
+      };
+    } catch (error) {
+      Logger.error('[RevenueCatAdapter] Purchase failed: ' + String(error));
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Get user subscription status
+   */
+  async getUserSubscriptionStatus(
+    entitlementId: string,
+  ): Promise<{ isActive: boolean; details?: any }> {
+    this.ensureInitialized();
+
+    try {
+      const customerInfo = await Purchases.getCustomerInfo();
+      const entitlement = customerInfo.entitlements.active[entitlementId];
+
+      return {
+        isActive: !!entitlement,
+        details: entitlement || null,
+      };
+    } catch (error) {
+      Logger.error(
+        '[RevenueCatAdapter] Failed to get subscription status: ' +
+          String(error),
+      );
+      return {
+        isActive: false,
+        details: { error: String(error) },
+      };
+    }
+  }
+
+  /**
+   * Restore purchases
+   */
+  async restorePurchases(): Promise<{
+    success: boolean;
+    error?: string;
+    restoredEntitlements?: string[];
+  }> {
+    this.ensureInitialized();
+
+    try {
+      const customerInfo = await Purchases.restorePurchases();
+      Logger.info('[RevenueCatAdapter] Purchases restored');
+
+      const restoredEntitlements = Object.keys(
+        customerInfo.entitlements.active,
+      );
+
+      return {
+        success: true,
+        restoredEntitlements,
+      };
+    } catch (error) {
+      Logger.error(
+        '[RevenueCatAdapter] Failed to restore purchases: ' + String(error),
+      );
+      return {
+        success: false,
+        error: String(error),
+      };
+    }
+  }
+
+  /**
+   * Record consumable purchase (not typically used with RevenueCat subscriptions)
+   */
+  async recordConsumablePurchase(_details: {
+    productId: string;
+    quantity: number;
+    transactionDetails: any;
+  }): Promise<{ success: boolean; error?: string }> {
+    Logger.warn(
+      '[RevenueCatAdapter] recordConsumablePurchase not implemented for RevenueCat',
+    );
+    return {
+      success: false,
+      error: 'Consumable purchases not supported by RevenueCat adapter',
+    };
+  }
+
+  /**
+   * Set user ID for RevenueCat
+   */
+  static async setUserId(userId: string) {
+    RevenueCatAdapter.ensureInitialized();
+    try {
+      const { customerInfo } = await Purchases.logIn(userId);
+      Logger.info(`[RevenueCatAdapter] User logged in: ${userId}`);
+      return customerInfo;
+    } catch (error) {
+      Logger.error(
+        '[RevenueCatAdapter] Failed to set user ID: ' + String(error),
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Log out the current user
+   */
+  static async logOut() {
+    RevenueCatAdapter.ensureInitialized();
+    try {
+      const customerInfo = await Purchases.logOut();
+      Logger.info('[RevenueCatAdapter] User logged out');
+      return customerInfo;
+    } catch (error) {
+      Logger.error(
+        '[RevenueCatAdapter] Failed to log out user: ' + String(error),
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Ensure the SDK is initialized before making calls
+   * @private
+   */
+  private ensureInitialized(): void {
+    if (!RevenueCatAdapter.isInitialized) {
+      throw new Error(
+        '[RevenueCatAdapter] SDK not initialized. Call initialize() first.',
+      );
+    }
+  }
+
+  /**
+   * Static version for class-level calls
+   * @private
+   */
+  private static ensureInitialized(): void {
+    if (!RevenueCatAdapter.isInitialized) {
+      throw new Error(
+        '[RevenueCatAdapter] SDK not initialized. Call initialize() first.',
+      );
+    }
+  }
+
+  /**
+   * Check if a product ID represents a consumable purchase (credits)
+   * @private
+   */
+  private isConsumableProduct(productId: string): boolean {
+    // Define patterns for consumable products (credits)
+    return productId.includes('credits') || productId.includes('credit');
+  }
+
+  /**
+   * Get the number of credits for a consumable product
+   * @private
+   */
+  private getConsumableQuantity(productId: string): number {
+    // Extract quantity from product ID patterns
+    const patterns = [
+      /credits?[_-]?(\d+)/i, // credits_100, credit_50, credits100
+      /(\d+)[_-]?credits?/i, // 100_credits, 50credit, 100credits
+    ];
+
+    for (const pattern of patterns) {
+      const match = productId.match(pattern);
+      if (match && match[1]) {
+        const quantity = Number.parseInt(match[1], 10);
+        if (!isNaN(quantity) && quantity > 0) {
+          return quantity;
+        }
+      }
+    }
+
+    // Default to 1 credit if pattern not recognized
+    Logger.warn(
+      `[RevenueCatAdapter] Could not parse quantity from productId: ${productId}, defaulting to 1`,
+    );
+    return 1;
+  }
+}

package/recipes/payments/recipe.json

@@ -0,0 +1,58 @@
+{
+  "name": "payments",
+  "version": "1.0.0",
+  "description": "In-app purchases and subscriptions with RevenueCat",
+  "copy": [
+    {
+      "from": "apps/native/src/app/(root)/(protected)/paywall",
+      "to": "apps/native/src/app/(root)/(protected)/paywall"
+    },
+    {
+      "from": "apps/native/src/features/payments",
+      "to": "apps/native/src/features/payments"
+    }
+  ],
+  "nav": {
+    "href": "/(root)/(protected)/paywall",
+    "label": "Paywall",
+    "icon": "💳",
+    "color": "#10B981"
+  },
+  "target": "native",
+  "dependencies": {
+    "expo": [
+      "react-native-purchases"
+    ]
+  },
+  "manualSteps": [
+    {
+      "title": "Create RevenueCat Account",
+      "description": "Sign up at revenuecat.com and create a new project",
+      "link": "https://app.revenuecat.com/signup"
+    },
+    {
+      "title": "Configure App Stores",
+      "description": "Link your iOS (App Store Connect) and Android (Google Play) apps to RevenueCat",
+      "link": "https://www.revenuecat.com/docs/getting-started"
+    },
+    {
+      "title": "Get API Keys",
+      "description": "Copy your public API keys (iOS and Android) from RevenueCat settings",
+      "link": "https://app.revenuecat.com/settings/api-keys"
+    },
+    {
+      "title": "Update API Keys",
+      "description": "Replace the API keys in the RevenueCat adapter",
+      "file": "apps/native/src/features/payments/services/revenuecat-adapter.ts",
+      "content": "const REVENUECAT_API_KEY_IOS = 'your_ios_key_here';\nconst REVENUECAT_API_KEY_ANDROID = 'your_android_key_here';"
+    },
+    {
+      "title": "Create Products & Entitlements",
+      "description": "Set up your subscription products and entitlements in RevenueCat dashboard",
+      "link": "https://www.revenuecat.com/docs/entitlements"
+    }
+  ],
+  "postInstall": {
+    "message": "💳 Payments feature installed! Configure RevenueCat API keys to enable subscriptions."
+  }
+}