vibefast-cli 1.1.5 → 1.2.1

package/recipes/payments-supabase/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-supabase/packages/backend/src/services/payments.ts

@@ -0,0 +1,201 @@
+/**
+ * Payments Service
+ *
+ * Handles credit purchases and purchase history operations.
+ * Uses the record_purchase database function for atomic credit updates.
+ *
+ * Requirements: 9.1, 9.2
+ */
+
+import type { SupabaseClientType } from '../lib/supabase';
+import type { Purchase } from '../types';
+
+export interface RecordPurchaseInput {
+  productId: string;
+  quantity: number;
+}
+
+export interface RecordPurchaseResult {
+  success: boolean;
+  purchase?: Purchase;
+  creditsAdded?: number;
+  newBalance?: number;
+  error?: string;
+}
+
+export interface GetPurchaseHistoryResult {
+  success: boolean;
+  purchases?: Purchase[];
+  hasMore?: boolean;
+  error?: string;
+}
+
+/**
+ * Record a consumable purchase and add credits to the user
+ *
+ * Premium products (containing 'premium' in product_id) receive 2x credits.
+ * Uses the record_purchase database function for atomic operations.
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param input - Purchase details (productId, quantity)
+ * @returns The purchase record and updated credit balance
+ *
+ * Requirements: 9.1
+ */
+export async function recordConsumablePurchase(
+  supabase: SupabaseClientType,
+  input: RecordPurchaseInput
+): Promise<RecordPurchaseResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  const { productId, quantity } = input;
+
+  // Validate input
+  if (!productId || productId.trim() === '') {
+    return { success: false, error: 'Product ID is required' };
+  }
+
+  if (!quantity || quantity < 1) {
+    return { success: false, error: 'Quantity must be at least 1' };
+  }
+
+  // Call the record_purchase database function for atomic operation
+  const { data, error } = await supabase.rpc('record_purchase', {
+    p_user_id: authData.user.id,
+    p_product_id: productId,
+    p_quantity: quantity,
+  });
+
+  if (error) {
+    return { success: false, error: `Failed to record purchase: ${error.message}` };
+  }
+
+  // The function returns an array with one row
+  const result = Array.isArray(data) ? data[0] : data;
+
+  if (!result) {
+    return { success: false, error: 'Failed to record purchase: no result returned' };
+  }
+
+  // Fetch the created purchase record
+  const { data: purchase, error: fetchError } = await supabase
+    .from('purchases')
+    .select('*')
+    .eq('id', result.purchase_id)
+    .single();
+
+  if (fetchError || !purchase) {
+    // Purchase was recorded but we couldn't fetch it - still return success
+    return {
+      success: true,
+      creditsAdded: result.credits_added,
+      newBalance: result.new_balance,
+    };
+  }
+
+  return {
+    success: true,
+    purchase,
+    creditsAdded: result.credits_added,
+    newBalance: result.new_balance,
+  };
+}
+
+
+/**
+ * Get purchase history for the current user
+ *
+ * Returns purchases ordered by date descending (newest first) with pagination.
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param options - Pagination options
+ * @returns List of purchases with pagination info
+ *
+ * Requirements: 9.2
+ */
+export async function getPurchaseHistory(
+  supabase: SupabaseClientType,
+  options: {
+    limit?: number;
+    offset?: number;
+  } = {}
+): Promise<GetPurchaseHistoryResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  const { limit = 20, offset = 0 } = options;
+
+  // Fetch purchases with pagination
+  const { data: purchases, error: listError, count } = await supabase
+    .from('purchases')
+    .select('*', { count: 'exact' })
+    .eq('user_id', authData.user.id)
+    .order('purchase_date', { ascending: false })
+    .range(offset, offset + limit - 1);
+
+  if (listError) {
+    return { success: false, error: `Failed to get purchase history: ${listError.message}` };
+  }
+
+  const hasMore = count !== null && offset + (purchases?.length || 0) < count;
+
+  return {
+    success: true,
+    purchases: purchases || [],
+    hasMore,
+  };
+}
+
+/**
+ * Get a single purchase by ID
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param purchaseId - The ID of the purchase
+ * @returns The purchase record or error
+ */
+export async function getPurchaseById(
+  supabase: SupabaseClientType,
+  purchaseId: string
+): Promise<{ success: boolean; purchase?: Purchase; error?: string }> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  if (!purchaseId) {
+    return { success: false, error: 'Purchase ID is required' };
+  }
+
+  const { data: purchase, error: getError } = await supabase
+    .from('purchases')
+    .select('*')
+    .eq('id', purchaseId)
+    .eq('user_id', authData.user.id)
+    .single();
+
+  if (getError) {
+    if (getError.code === 'PGRST116') {
+      return { success: false, error: 'Purchase not found' };
+    }
+    return { success: false, error: `Failed to get purchase: ${getError.message}` };
+  }
+
+  return { success: true, purchase };
+}
+
+export const paymentsService = {
+  recordConsumablePurchase,
+  getPurchaseHistory,
+  getPurchaseById,
+};

package/recipes/payments-supabase/packages/backend/supabase/migrations/payments.sql

@@ -0,0 +1,35 @@
+-- Payments Feature Migration
+-- Creates tables for purchases/credits tracking
+-- Run this migration when adding the payments feature via CLI
+
+-- ============================================================================
+-- PURCHASES TABLE
+-- Records credit purchases and transactions
+-- ============================================================================
+CREATE TABLE IF NOT EXISTS purchases (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  product_id TEXT NOT NULL,
+  quantity INTEGER NOT NULL,
+  credits_added INTEGER NOT NULL,
+  purchase_date TIMESTAMPTZ DEFAULT now()
+);
+
+-- ============================================================================
+-- INDEXES
+-- ============================================================================
+CREATE INDEX IF NOT EXISTS idx_purchases_user_id ON purchases(user_id);
+CREATE INDEX IF NOT EXISTS idx_purchases_purchase_date ON purchases(purchase_date);
+
+-- ============================================================================
+-- RLS POLICIES
+-- ============================================================================
+ALTER TABLE purchases ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY "purchases_select_own" ON purchases
+  FOR SELECT USING (auth.uid() = user_id);
+
+CREATE POLICY "purchases_insert_own" ON purchases
+  FOR INSERT WITH CHECK (auth.uid() = user_id);
+
+-- Note: UPDATE and DELETE not allowed for purchases (immutable records)

package/recipes/payments-supabase/recipe.json

@@ -0,0 +1,51 @@
+{
+  "name": "payments",
+  "version": "1.0.0",
+  "description": "RevenueCat payments with Supabase sync",
+  "copy": [
+    {
+      "from": "apps/native/src/features/payments",
+      "to": "apps/native/src/features/payments"
+    },
+    {
+      "from": "packages/backend/supabase/migrations/payments.sql",
+      "to": "packages/backend/supabase/migrations/payments.sql"
+    },
+    {
+      "from": "packages/backend/src/services/payments.ts",
+      "to": "packages/backend/src/services/payments.ts"
+    }
+  ],
+  "nav": {
+    "href": "/(root)/(protected)/payments",
+    "label": "Payments",
+    "icon": "💳",
+    "color": "#EC4899"
+  },
+  "target": "native",
+  "dependencies": {
+    "expo": [
+      "@supabase/supabase-js",
+      "react-native-purchases",
+      "react-native-purchases-ui"
+    ]
+  },
+  "env": [
+    {
+      "key": "REVENUECAT_API_KEY_APPLE",
+      "description": "RevenueCat API key for iOS",
+      "example": "appl_..."
+    },
+    {
+      "key": "REVENUECAT_API_KEY_GOOGLE",
+      "description": "RevenueCat API key for Android",
+      "example": "goog_..."
+    }
+  ],
+  "manualSteps": [
+    {
+      "title": "Apply Supabase migration",
+      "description": "Run: cd packages/backend && supabase db push"
+    }
+  ]
+}

package/recipes/quiz/apps/native/src/features/quiz/index.tsx

@@ -3,9 +3,8 @@ import { useRouter } from 'expo-router';
 import { AnimatePresence, MotiView } from 'moti';
 import { useState } from 'react';
 import { View } from 'react-native';
-import { SafeAreaView } from 'react-native-safe-area-context';
 
-import { Button, Text } from '@/components/ui';
+import { Button, SafeAreaView, Text } from '@/components/ui';
 
 import Question from './components/question';
 import { QuestionMode, quizConfig } from './config';