Webhooks

// Environment configuration
const WEBHOOK_SECRET = process.env.REVENUECAT_WEBHOOK_SECRET || 'MYSECRET';
const REVENUECAT_API_KEY = process.env.REVENUECAT_API_KEY;

/**
 * Main webhook handler
 * POST /webhooks/revenuecat
 */
async function handleRevenueCatWebhook(req, res) {
  try {
    // Step 1: Validate Authorization Header
    if (!validateAuthorization(req)) {
      console.warn('Unauthorized webhook attempt');
      return res.status(401).json({ error: 'Unauthorized' });
    }
    
    // Step 2: Parse webhook body
    const event = req.body?.event;
    if (!event) {
      console.error('Invalid webhook body - missing event');
      return res.status(400).json({ error: 'Invalid webhook body' });
    }
    
    // Step 3: Extract key information
    const eventType = event.type;
    const appUserId = event.app_user_id;
    const environment = event.environment; // PRODUCTION or SANDBOX
    const eventId = event.id;
    
    console.log(`Processing webhook: ${eventType} for user ${appUserId} (${environment})`);
    
    // Step 4: Check for duplicate event (idempotency)
    const isDuplicate = await checkDuplicateEvent(eventId);
    if (isDuplicate) {
      console.log(`Duplicate event ${eventId} - already processed`);
      return res.status(200).json({ message: 'Event already processed' });
    }
    
    // Step 5: Extract entitlements and subscriber info
    const activeEntitlements = extractEntitlementsFromEvent(event);
    const subscriberAttributes = event.subscriber_attributes || {};
    const externalUserId = subscriberAttributes.$email?.value || 
                          subscriberAttributes.$displayName?.value || 
                          appUserId;
    
    // Step 6: Process event based on type
    await processWebhookEvent({
      eventType,
      appUserId,
      externalUserId,
      environment,
      activeEntitlements,
      subscriberAttributes,
      event
    });
    
    // Step 7: Sync entitlements to database
    await syncEntitlementsToDatabase(appUserId, activeEntitlements, event);
    
    // Step 8: Mark event as processed
    await markEventAsProcessed(eventId);
    
    // Step 9: Return success
    return res.status(200).json({ message: 'Webhook processed successfully' });
    
  } catch (error) {
    console.error('Webhook processing error:', error);
    
    // Return 200 to prevent retries for our internal errors
    // Return 500 only if we want RevenueCat to retry
    return res.status(200).json({ 
      message: 'Webhook received but processing failed',
      error: error.message 
    });
  }
}

/**
 * Validate Authorization Header
 * RevenueCat sends: Authorization: Bearer MYSECRET
 * We validate against configured secret
 */
function validateAuthorization(req) {
  const authHeader = req.headers.authorization;
  
  if (!authHeader) {
    return false;
  }
  
  // Strip "Bearer " prefix if present
  const token = authHeader.startsWith('Bearer ') 
    ? authHeader.slice(7) 
    : authHeader;
  
  return token === WEBHOOK_SECRET;
}

/**
 * Process webhook event based on type
 */
async function processWebhookEvent({ eventType, appUserId, externalUserId, environment, activeEntitlements, event }) {
  
  // Extract critical entitlement data from webhook
  const entitlementData = extractEntitlementData(event);
  
  // Always sync entitlements to database for ALL events
  // This ensures database stays in sync with RevenueCat
  await syncEntitlementsToDatabase(appUserId, entitlementData, event);
  
  // Get detailed subscriber data if needed for complex processing
  // const subscriberData = await fetchSubscriberData(appUserId);
  
  switch (eventType) {
    
    // ==========================================
    // PURCHASE EVENTS
    // ==========================================
    
    case 'INITIAL_PURCHASE':
      console.log(`Initial purchase for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Grant access to premium features
      // - Update user status in database
      // - Send welcome email
      // - Track conversion in analytics
      // - Update subscription tier
      
      await handleInitialPurchase({
        appUserId,
        externalUserId,
        activeEntitlements,
        productId: event.product_id,
        price: event.price,
        currency: event.currency,
        purchaseDate: event.purchased_at_ms,
        expirationDate: event.expiration_at_ms,
        store: event.store,
        isTrialConversion: event.is_trial_conversion
      });
      break;
      
    case 'RENEWAL':
      console.log(`Renewal for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Extend subscription access
      // - Update next billing date
      // - Log successful payment
      // - Update LTV metrics
      
      await handleRenewal({
        appUserId,
        externalUserId,
        activeEntitlements,
        expirationDate: event.expiration_at_ms,
        price: event.price,
        currency: event.currency
      });
      break;
      
    case 'NON_RENEWING_PURCHASE':
      console.log(`Non-renewing purchase for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Grant time-limited access
      // - Set expiration date
      // - No auto-renewal expected
      
      await handleNonRenewingPurchase({
        appUserId,
        externalUserId,
        activeEntitlements,
        productId: event.product_id,
        expirationDate: event.expiration_at_ms
      });
      break;
    
    // ==========================================
    // CANCELLATION EVENTS
    // ==========================================
    
    case 'CANCELLATION':
      console.log(`Cancellation for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Schedule access removal at period end
      // - Send feedback survey
      // - Offer win-back discount
      // - Update churn analytics
      // - Flag account as "cancelled"
      
      await handleCancellation({
        appUserId,
        externalUserId,
        activeEntitlements,
        expirationDate: event.expiration_at_ms,
        cancellationReason: event.cancellation_reason,
        autoResumeDate: event.auto_resume_at_ms
      });
      break;
      
    case 'UNCANCELLATION':
      console.log(`Uncancellation for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Restore subscription to active state
      // - Remove cancellation flag
      // - Send confirmation email
      
      await handleUncancellation({
        appUserId,
        externalUserId,
        activeEntitlements,
        expirationDate: event.expiration_at_ms
      });
      break;
    
    // ==========================================
    // TRIAL EVENTS
    // ==========================================
    
    case 'TRIAL_STARTED':
      console.log(`Trial started for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Grant trial access to features
      // - Set trial end date
      // - Send onboarding emails
      // - Track trial starts
      
      await handleTrialStarted({
        appUserId,
        externalUserId,
        activeEntitlements,
        expirationDate: event.expiration_at_ms,
        productId: event.product_id
      });
      break;
      
    case 'TRIAL_CANCELLED':
      console.log(`Trial cancelled for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Remove trial access
      // - Send feedback survey
      // - Update trial conversion metrics
      
      await handleTrialCancelled({
        appUserId,
        externalUserId,
        cancellationReason: event.cancellation_reason
      });
      break;
    
    // ==========================================
    // BILLING EVENTS
    // ==========================================
    
    case 'BILLING_ISSUE':
      console.log(`Billing issue for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Flag account with payment problem
      // - Send payment update reminder
      // - Start grace period
      // - Alert user via email/push
      
      await handleBillingIssue({
        appUserId,
        externalUserId,
        activeEntitlements,
        gracePeriodExpiresAt: event.grace_period_expires_at_ms
      });
      break;
      
    case 'EXPIRATION':
      console.log(`Subscription expired for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Remove premium access
      // - Archive user data
      // - Send win-back campaign
      // - Update user to free tier
      
      await handleExpiration({
        appUserId,
        externalUserId,
        expirationReason: event.expiration_reason,
        expirationDate: event.expiration_at_ms
      });
      break;
    
    // ==========================================
    // REFUND EVENTS
    // ==========================================
    
    case 'REFUND':
      console.log(`Refund issued for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Revoke access immediately
      // - Log refund for accounting
      // - Update analytics
      // - Flag potential abuse
      
      await handleRefund({
        appUserId,
        externalUserId,
        productId: event.product_id,
        price: event.price,
        currency: event.currency
      });
      break;
      
    case 'REFUND_REVERSED':
      console.log(`Refund reversed for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Restore access
      // - Update accounting records
      // - Notify user
      
      await handleRefundReversed({
        appUserId,
        externalUserId,
        activeEntitlements
      });
      break;
    
    // ==========================================
    // SUBSCRIPTION CHANGES
    // ==========================================
    
    case 'PRODUCT_CHANGE':
      console.log(`Product changed for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Update tier/plan
      // - Adjust feature access
      // - Update usage limits
      // - Log upgrade or downgrade
      
      await handleProductChange({
        appUserId,
        externalUserId,
        activeEntitlements,
        newProductId: event.new_product_id,
        oldProductId: event.product_id,
        expirationDate: event.expiration_at_ms
      });
      break;
      
    case 'SUBSCRIPTION_PAUSED':
      console.log(`Subscription paused for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Temporarily suspend access
      // - Set auto-resume date
      // - Update UI to show paused state
      
      await handleSubscriptionPaused({
        appUserId,
        externalUserId,
        autoResumeDate: event.auto_resume_at_ms
      });
      break;
      
    case 'SUBSCRIPTION_EXTENDED':
      console.log(`Subscription extended for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Update expiration date
      // - Log extension reason
      // - Send confirmation
      
      await handleSubscriptionExtended({
        appUserId,
        externalUserId,
        newExpirationDate: event.expiration_at_ms,
        extensionReason: 'promotional' // or from event data
      });
      break;
    
    // ==========================================
    // TRANSFER EVENTS
    // ==========================================
    
    case 'TRANSFER':
      console.log(`Subscription transferred for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Move subscription to new user
      // - Update ownership records
      // - Sync across accounts
      
      await handleTransfer({
        fromUserId: event.transferred_from?.[0],
        toUserId: appUserId,
        activeEntitlements
      });
      break;
    
    // ==========================================
    // SPECIAL EVENTS
    // ==========================================
    
    case 'INVOICE_ISSUANCE':
      console.log(`Invoice issued for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Store invoice data
      // - Send to accounting system
      // - Update billing records
      
      await handleInvoiceIssuance({
        appUserId,
        externalUserId,
        invoiceData: event
      });
      break;
      
    case 'TEMPORARY_ENTITLEMENT_GRANT':
      console.log(`Temporary entitlement granted for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Grant temporary access (store issue)
      // - Set auto-expiry
      // - Log for monitoring
      
      await handleTemporaryEntitlement({
        appUserId,
        externalUserId,
        activeEntitlements,
        expirationDate: event.expiration_at_ms
      });
      break;
      
    case 'VIRTUAL_CURRENCY_TRANSACTION':
      console.log(`Virtual currency transaction for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Update virtual currency balance
      // - Log transaction
      // - Sync wallet state
      
      await handleVirtualCurrency({
        appUserId,
        externalUserId,
        amount: event.amount,
        currency: event.currency,
        transactionType: event.transaction_type
      });
      break;
      
    case 'EXPERIMENT_ENROLLMENT':
      console.log(`Experiment enrollment for ${appUserId}`);
      
      // TODO: Implement your logic
      // - Assign user to variant
      // - Track enrollment
      // - Update analytics
      
      await handleExperimentEnrollment({
        appUserId,
        externalUserId,
        experimentId: event.experiment_id,
        variantId: event.variant_id
      });
      break;
    
    // ==========================================
    // UNKNOWN EVENTS (Future-proofing)
    // ==========================================
    
    default:
      console.warn(`Unknown event type: ${eventType}`);
      
      // TODO: Implement your logic
      // - Log for review
      // - Alert team
      // - Store for manual processing
      
      await handleUnknownEvent({
        eventType,
        appUserId,
        externalUserId,
        event
      });
      break;
  }
}

/**
 * Fetch complete subscriber data from RevenueCat API
 * Recommended after processing webhook for consistent data format
 */
async function fetchSubscriberData(appUserId) {
  try {
    const response = await fetch(
      `https://api.revenuecat.com/v1/subscribers/${appUserId}`,
      {
        headers: {
          'Authorization': `Bearer ${REVENUECAT_API_KEY}`,
          'Content-Type': 'application/json',
          'X-Platform': 'stripe' // Optional: helps with analytics
        }
      }
    );
    
    if (!response.ok) {
      throw new Error(`RevenueCat API error: ${response.status}`);
    }
    
    const data = await response.json();
    return data.subscriber;
    
  } catch (error) {
    console.error('Error fetching subscriber data:', error);
    return null;
  }
}

/**
 * Fetch customer data from RevenueCat API V2 (recommended for real-time checks)
 * Use this as authoritative source of truth when validating subscription status
 */
async function fetchCustomerDataV2(customerId, projectId) {
  try {
    const response = await fetch(
      `https://api.revenuecat.com/v2/projects/${projectId}/customers/${customerId}`,
      {
        headers: {
          'Authorization': `Bearer ${REVENUECAT_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    if (!response.ok) {
      if (response.status === 404) {
        console.warn(`Customer ${customerId} not found in RevenueCat`);
        return null;
      }
      throw new Error(`RevenueCat V2 API error: ${response.status}`);
    }
    
    const data = await response.json();
    return data;
    
  } catch (error) {
    console.error('Error fetching customer data from V2 API:', error);
    return null;
  }
}

/**
 * Self-healing subscription status check
 * 1. Check database first (fast)
 * 2. If discrepancy detected, verify with RevenueCat V2 API
 * 3. Sync database if mismatch found
 */
async function verifyAndSyncSubscriptionStatus(appUserId, projectId) {
  try {
    // Step 1: Get current database status
    const dbStatus = await getSubscriptionStatusFromDB(appUserId);
    
    // Step 2: Get authoritative status from RevenueCat V2
    const rcData = await fetchCustomerDataV2(appUserId, projectId);
    
    if (!rcData) {
      console.warn(`Customer ${appUserId} not found in RevenueCat`);
      return dbStatus; // Trust database if customer doesn't exist
    }
    
    // Step 3: Check for active entitlements
    // V2 API returns expires_at as milliseconds timestamp
    const hasActiveEntitlements = rcData.active_entitlements?.items?.length > 0;
    const rcIsActive = hasActiveEntitlements && 
      rcData.active_entitlements.items.some(ent => {
        return ent.expires_at > Date.now();
      });
    
    // Step 4: Detect discrepancy
    if (dbStatus?.is_active !== rcIsActive) {
      console.warn(`Subscription status mismatch for ${appUserId}:`, {
        database: dbStatus?.is_active ? 'active' : 'inactive',
        revenuecat: rcIsActive ? 'active' : 'inactive'
      });
      
      // Step 5: Sync database with RevenueCat (source of truth)
      await syncDatabaseWithRevenueCat(appUserId, rcData);
      
      console.log(`Synced ${appUserId} subscription status from RevenueCat`);
    }
    
    // Extract customer email and display name from attributes
    const email = rcData.attributes?.items?.find(attr => attr.name === '$email')?.value || null;
    const displayName = rcData.attributes?.items?.find(attr => attr.name === '$displayName')?.value || null;
    
    return {
      appUserId,
      isActive: rcIsActive,
      entitlements: rcData.active_entitlements?.items || [],
      email,
      displayName,
      lastSeen: rcData.last_seen_at,
      experiment: rcData.experiment,
      syncedAt: new Date()
    };
    
  } catch (error) {
    console.error('Error in verifyAndSyncSubscriptionStatus:', error);
    
    // Fallback to database status on error
    const dbStatus = await getSubscriptionStatusFromDB(appUserId);
    return dbStatus;
  }
}

/**
 * Get subscription status from database
 */
async function getSubscriptionStatusFromDB(appUserId) {
  // TODO: Implement with your database
  // Example:
  // const result = await db.query(
  //   'SELECT * FROM user_subscriptions WHERE app_user_id = $1',
  //   [appUserId]
  // );
  // return result.rows[0];
  
  return null;
}

/**
 * Sync database with RevenueCat data
 */
async function syncDatabaseWithRevenueCat(appUserId, rcData) {
  // TODO: Implement with your database
  // Update user_subscriptions table with V2 API data
  
  const hasActiveEntitlements = rcData.active_entitlements?.items?.length > 0;
  
  // Extract email and display name from attributes
  const email = rcData.attributes?.items?.find(attr => attr.name === '$email')?.value || null;
  const displayName = rcData.attributes?.items?.find(attr => attr.name === '$displayName')?.value || null;
  
  // Get latest expiration from active entitlements
  const latestExpiration = hasActiveEntitlements 
    ? Math.max(...rcData.active_entitlements.items.map(ent => ent.expires_at))
    : null;
  
  // Convert entitlements to database format
  const entitlementsForDB = {};
  if (hasActiveEntitlements) {
    rcData.active_entitlements.items.forEach(ent => {
      entitlementsForDB[ent.entitlement_id] = {
        entitlement_id: ent.entitlement_id,
        expires_at: ent.expires_at
      };
    });
  }
  
  // Example database sync:
  // await db.query(`
  //   UPDATE user_subscriptions 
  //   SET 
  //     is_active = $1,
  //     entitlements = $2,
  //     expires_at = $3,
  //     email = $4,
  //     external_user_id = $5,
  //     last_seen_at = $6,
  //     last_revenuecat_sync_at = NOW()
  //   WHERE app_user_id = $7
  // `, [
  //   hasActiveEntitlements,
  //   JSON.stringify(entitlementsForDB),
  //   latestExpiration ? new Date(latestExpiration) : null,
  //   email,
  //   displayName || email,
  //   rcData.last_seen_at ? new Date(rcData.last_seen_at) : null,
  //   appUserId
  // ]);
  
  console.log(`Database synced for ${appUserId}`, {
    hasActive: hasActiveEntitlements,
    entitlementCount: Object.keys(entitlementsForDB).length,
    email,
    latestExpiration: latestExpiration ? new Date(latestExpiration).toISOString() : null
  });
}

/**
 * Extract complete entitlement data from webhook event
 * Based on actual RevenueCat webhook structure
 */
function extractEntitlementData(event) {
  return {
    // Entitlements (the key field!)
    entitlements: event.entitlements || {},
    
    // User identification
    appUserId: event.app_user_id,
    originalAppUserId: event.original_app_user_id,
    aliases: event.aliases || [],
    
    // Subscriber attributes (email, displayName, custom attributes)
    subscriberAttributes: event.subscriber_attributes || {},
    
    // Product information
    productId: event.product_id || event.new_product_id,
    oldProductId: event.product_id, // For product changes
    newProductId: event.new_product_id, // For product changes
    
    // Subscription dates
    purchasedAtMs: event.purchased_at_ms,
    expirationAtMs: event.expiration_at_ms,
    originalPurchaseDateMs: event.original_purchase_date_ms,
    
    // Grace period (billing issues)
    gracePeriodExpiresAtMs: event.grace_period_expires_at_ms,
    
    // Trial information
    isTrialConversion: event.is_trial_conversion,
    
    // Cancellation
    cancellationReason: event.cancellation_reason,
    autoResumeAtMs: event.auto_resume_at_ms,
    
    // Expiration reason
    expirationReason: event.expiration_reason,
    
    // Transfer information
    transferredFrom: event.transferred_from,
    transferredTo: event.transferred_to,
    
    // Metadata
    store: event.store,
    environment: event.environment,
    periodType: event.period_type,
    
    // Pricing
    price: event.price,
    priceInPurchasedCurrency: event.price_in_purchased_currency,
    currency: event.currency,
    
    // Event tracking
    eventId: event.id,
    eventType: event.type,
    eventTimestampMs: event.event_timestamp_ms
  };
}

/**
 * Extract entitlements from webhook event
 * Handles the nested structure from RevenueCat webhooks
 * 
 * IMPORTANT: Entitlements structure from RevenueCat:
 * {
 *   "entitlement_id": {
 *     "expires_date": "2026-01-17T12:00:00Z",
 *     "grace_period_expires_date": null,
 *     "product_identifier": "yearly_pro",
 *     "purchase_date": "2025-01-17T12:00:00Z"
 *   }
 * }
 */
function extractEntitlementsFromEvent(event) {
  // Entitlements are nested under event.entitlements
  // Structure: { entitlement_id: { expires_date, product_identifier, ... } }
  const entitlements = event.entitlements || {};
  
  // Convert to array format with expiration checking
  const activeEntitlements = {};
  
  Object.keys(entitlements).forEach(entitlementId => {
    const entitlement = entitlements[entitlementId];
    
    // Check if entitlement is active
    const expiresDate = entitlement.expires_date;
    const isActive = !expiresDate || new Date(expiresDate) > new Date();
    
    if (isActive) {
      activeEntitlements[entitlementId] = {
        entitlement_id: entitlementId,
        product_id: entitlement.product_identifier,
        expires_at: expiresDate,
        purchase_date: entitlement.purchase_date,
        grace_period_expires_at: entitlement.grace_period_expires_date
      };
    }
  });
  
  return activeEntitlements;
}

/**
 * Sync entitlements to database
 * Updates user_subscriptions table with current entitlements from webhook
 * 
 * CRITICAL: This function MUST be called for EVERY webhook event to keep
 * the database in sync with RevenueCat's source of truth
 */
async function syncEntitlementsToDatabase(appUserId, entitlementData, event) {
  try {
    // Extract entitlements
    const entitlements = entitlementData.entitlements || event.entitlements || {};
    const activeEntitlements = extractEntitlementsFromEvent({ entitlements });
    const hasActiveEntitlements = Object.keys(activeEntitlements).length > 0;
    
    // Get subscriber attributes
    const subscriberAttributes = entitlementData.subscriberAttributes || event.subscriber_attributes || {};
    const email = subscriberAttributes.$email?.value || null;
    const displayName = subscriberAttributes.$displayName?.value || null;
    
    // Product information
    const productId = entitlementData.productId || event.product_id || event.new_product_id;
    
    // Dates
    const expiresAt = entitlementData.expirationAtMs 
      ? new Date(entitlementData.expirationAtMs) 
      : (event.expiration_at_ms ? new Date(event.expiration_at_ms) : null);
    
    const purchasedAt = entitlementData.purchasedAtMs
      ? new Date(entitlementData.purchasedAtMs)
      : (event.purchased_at_ms ? new Date(event.purchased_at_ms) : null);
    
    const gracePeriodExpiresAt = entitlementData.gracePeriodExpiresAtMs
      ? new Date(entitlementData.gracePeriodExpiresAtMs)
      : (event.grace_period_expires_at_ms ? new Date(event.grace_period_expires_at_ms) : null);
    
    // Determine subscription status based on event type
    let subscriptionStatus = 'expired';
    let autoRenew = true;
    let billingIssue = false;
    let cancelledAt = null;
    
    if (hasActiveEntitlements) {
      if (event.type === 'TRIAL_STARTED') {
        subscriptionStatus = 'trial';
      } else if (event.type === 'SUBSCRIPTION_PAUSED') {
        subscriptionStatus = 'paused';
        autoRenew = false;
      } else if (event.type === 'CANCELLATION') {
        subscriptionStatus = 'cancelled';
        autoRenew = false;
        cancelledAt = new Date(event.event_timestamp_ms || Date.now());
      } else if (event.type === 'BILLING_ISSUE') {
        subscriptionStatus = 'billing_issue';
        billingIssue = true;
      } else {
        subscriptionStatus = 'active';
      }
    } else {
      // No active entitlements
      subscriptionStatus = 'expired';
      autoRenew = false;
    }
    
    // Store information
    const store = entitlementData.store || event.store;
    const environment = entitlementData.environment || event.environment;
    
    console.log(`Syncing entitlements for ${appUserId}:`, {
      hasActive: hasActiveEntitlements,
      status: subscriptionStatus,
      entitlementCount: Object.keys(activeEntitlements).length,
      entitlements: Object.keys(activeEntitlements),
      productId,
      expiresAt,
      email
    });
    
    // TODO: Implement database update
    // This is the CRITICAL sync point - update your database here
    /*
    await db.query(`
      INSERT INTO user_subscriptions (
        app_user_id,
        external_user_id,
        email,
        is_active,
        subscription_status,
        product_id,
        entitlements,
        expires_at,
        purchased_at,
        cancelled_at,
        grace_period_expires_at,
        auto_renew,
        billing_issue,
        store,
        environment,
        last_webhook_event_id,
        last_webhook_event_type,
        last_updated
      ) VALUES (
        $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, NOW()
      )
      ON CONFLICT (app_user_id) 
      DO UPDATE SET
        external_user_id = COALESCE(EXCLUDED.external_user_id, user_subscriptions.external_user_id),
        email = COALESCE(EXCLUDED.email, user_subscriptions.email),
        is_active = EXCLUDED.is_active,
        subscription_status = EXCLUDED.subscription_status,
        product_id = EXCLUDED.product_id,
        entitlements = EXCLUDED.entitlements,
        expires_at = EXCLUDED.expires_at,
        purchased_at = COALESCE(EXCLUDED.purchased_at, user_subscriptions.purchased_at),
        cancelled_at = EXCLUDED.cancelled_at,
        grace_period_expires_at = EXCLUDED.grace_period_expires_at,
        auto_renew = EXCLUDED.auto_renew,
        billing_issue = EXCLUDED.billing_issue,
        store = EXCLUDED.store,
        environment = EXCLUDED.environment,
        last_webhook_event_id = EXCLUDED.last_webhook_event_id,
        last_webhook_event_type = EXCLUDED.last_webhook_event_type,
        last_updated = NOW()
    `, [
      appUserId,
      displayName || email,
      email,
      hasActiveEntitlements,
      subscriptionStatus,
      productId,
      JSON.stringify(activeEntitlements),
      expiresAt,
      purchasedAt,
      cancelledAt,
      gracePeriodExpiresAt,
      autoRenew,
      billingIssue,
      store,
      environment,
      event.id,
      event.type
    ]);
    */
    
    // Also sync to normalized entitlements table
    await syncEntitlementsToNormalizedTable(appUserId, activeEntitlements, event);
    
  } catch (error) {
    console.error('Error syncing entitlements to database:', error);
    throw error;
  }
}

/**
 * Check for duplicate event (idempotency)
 */
async function checkDuplicateEvent(eventId) {
  // TODO: Implement with your database
  // Check if eventId exists in processed_events table
  // Return true if exists, false otherwise
  
  // Example:
  // const exists = await db.query(
  //   'SELECT 1 FROM processed_webhook_events WHERE event_id = $1',
  //   [eventId]
  // );
  // return exists.rows.length > 0;
  
  return false;
}

/**
 * Mark event as processed
 */
async function markEventAsProcessed(eventId) {
  // TODO: Implement with your database
  // Insert eventId into processed_events table
  
  // Example:
  // await db.query(
  //   'INSERT INTO processed_webhook_events (event_id, processed_at) VALUES ($1, NOW())',
  //   [eventId]
  // );
}

// ==========================================
// EVENT HANDLER TEMPLATES
// Implement these functions with your business logic
// ==========================================

async function handleInitialPurchase(data) {
  // TODO: Implement
  // - Update user subscription status in database
  // - Grant access to premium features
  // - Send welcome email
  // - Track conversion event in analytics
  
  console.log('Initial purchase handler - implement your logic here', data);
}

async function handleRenewal(data) {
  // TODO: Implement
  // - Update subscription end date
  // - Log successful payment
  // - Update customer LTV
  
  console.log('Renewal handler - implement your logic here', data);
}

async function handleNonRenewingPurchase(data) {
  // TODO: Implement
  console.log('Non-renewing purchase handler - implement your logic here', data);
}

async function handleCancellation(data) {
  // TODO: Implement
  // - Update subscription status to "cancelled"
  // - Schedule access removal for expiration date
  // - Send feedback survey
  // - Track churn reason
  
  console.log('Cancellation handler - implement your logic here', data);
}

async function handleUncancellation(data) {
  // TODO: Implement
  console.log('Uncancellation handler - implement your logic here', data);
}

async function handleTrialStarted(data) {
  // TODO: Implement
  console.log('Trial started handler - implement your logic here', data);
}

async function handleTrialCancelled(data) {
  // TODO: Implement
  console.log('Trial cancelled handler - implement your logic here', data);
}

async function handleBillingIssue(data) {
  // TODO: Implement
  // - Flag account
  // - Send payment reminder email
  // - Start grace period
  
  console.log('Billing issue handler - implement your logic here', data);
}

async function handleExpiration(data) {
  // TODO: Implement
  // - Remove premium access
  // - Downgrade to free tier
  // - Send win-back email
  
  console.log('Expiration handler - implement your logic here', data);
}

async function handleRefund(data) {
  // TODO: Implement
  // - Immediately revoke access
  // - Log refund
  // - Update accounting
  
  console.log('Refund handler - implement your logic here', data);
}

async function handleRefundReversed(data) {
  // TODO: Implement
  console.log('Refund reversed handler - implement your logic here', data);
}

async function handleProductChange(data) {
  // TODO: Implement
  // - Update subscription tier
  // - Adjust feature access
  // - Log upgrade/downgrade
  
  console.log('Product change handler - implement your logic here', data);
}

async function handleSubscriptionPaused(data) {
  // TODO: Implement
  console.log('Subscription paused handler - implement your logic here', data);
}

async function handleSubscriptionExtended(data) {
  // TODO: Implement
  console.log('Subscription extended handler - implement your logic here', data);
}

async function handleTransfer(data) {
  // TODO: Implement
  console.log('Transfer handler - implement your logic here', data);
}

async function handleInvoiceIssuance(data) {
  // TODO: Implement
  console.log('Invoice issuance handler - implement your logic here', data);
}

async function handleTemporaryEntitlement(data) {
  // TODO: Implement
  console.log('Temporary entitlement handler - implement your logic here', data);
}

async function handleVirtualCurrency(data) {
  // TODO: Implement
  console.log('Virtual currency handler - implement your logic here', data);
}

async function handleExperimentEnrollment(data) {
  // TODO: Implement
  console.log('Experiment enrollment handler - implement your logic here', data);
}

async function handleUnknownEvent(data) {
  // TODO: Implement
  // - Log event for manual review
  // - Alert development team
  // - Store in database for later processing
  
  console.log('Unknown event handler - implement your logic here', data);
}

// ==========================================
// HELPER FUNCTIONS
// ==========================================

/**
 * Check if user has active entitlement (V2 API format)
 * V2 API returns expires_at as milliseconds timestamp
 */
function hasActiveEntitlementV2(customerData, entitlementId = null) {
  if (!customerData?.active_entitlements?.items) {
    return false;
  }
  
  return customerData.active_entitlements.items.some(ent => {
    // If entitlementId specified, check for specific entitlement
    if (entitlementId && ent.entitlement_id !== entitlementId) {
      return false;
    }
    
    // Check if entitlement is still valid
    // expires_at is in milliseconds timestamp
    return ent.expires_at > Date.now();
  });
}

/**
 * Determine if we should verify status with RevenueCat
 */
function shouldVerifyWithRevenueCat(cachedStatus) {
  if (!cachedStatus) {
    return true; // No cached data, must check
  }
  
  // Always verify if subscription expires soon (within 24 hours)
  if (cachedStatus.expires_at) {
    const expiresAt = new Date(cachedStatus.expires_at);
    const hoursUntilExpiry = (expiresAt - new Date()) / (1000 * 60 * 60);
    
    if (hoursUntilExpiry < 24) {
      return true; // Verify near expiration
    }
  }
  
  // Verify if billing issue detected
  if (cachedStatus.billing_issue) {
    return true;
  }
  
  // Verify if recently cancelled (within 48 hours)
  if (cachedStatus.cancelled_at) {
    const cancelledAt = new Date(cachedStatus.cancelled_at);
    const hoursSinceCancellation = (new Date() - cancelledAt) / (1000 * 60 * 60);
    
    if (hoursSinceCancellation < 48) {
      return true; // Verify recent cancellations
    }
  }
  
  // Verify if cache is stale (older than 1 hour)
  if (cachedStatus.last_updated) {
    const lastUpdated = new Date(cachedStatus.last_updated);
    const hoursSinceUpdate = (new Date() - lastUpdated) / (1000 * 60 * 60);
    
    if (hoursSinceUpdate > 1) {
      return true; // Cache is stale
    }
  }
  
  return false; // Use cached data
}

/**
 * Check if user has active entitlement
 */
function hasActiveEntitlement(activeEntitlements, entitlementId) {
  return activeEntitlements[entitlementId]?.expires_date_ms 
    ? activeEntitlements[entitlementId].expires_date_ms > Date.now()
    : false;
}

/**
 * Get all active entitlement IDs
 */
function getActiveEntitlementIds(activeEntitlements) {
  return Object.keys(activeEntitlements).filter(entitlementId => 
    hasActiveEntitlement(activeEntitlements, entitlementId)
  );
}

/**
 * Get all active entitlement IDs from V2 API customer data
 */
function getActiveEntitlementIdsV2(customerData) {
  if (!customerData?.active_entitlements?.items) {
    return [];
  }
  
  return customerData.active_entitlements.items
    .filter(ent => ent.expires_at > Date.now())
    .map(ent => ent.entitlement_id);
}

/**
 * Get customer email from V2 API attributes
 */
function getCustomerEmailV2(customerData) {
  if (!customerData?.attributes?.items) {
    return null;
  }
  
  const emailAttr = customerData.attributes.items.find(
    attr => attr.name === '$email'
  );
  
  return emailAttr?.value || null;
}

/**
 * Get customer display name from V2 API attributes
 */
function getCustomerDisplayNameV2(customerData) {
  if (!customerData?.attributes?.items) {
    return null;
  }
  
  const nameAttr = customerData.attributes.items.find(
    attr => attr.name === '$displayName'
  );
  
  return nameAttr?.value || null;
}

/**
 * Get custom attribute from V2 API customer data
 */
function getCustomerAttributeV2(customerData, attributeName) {
  if (!customerData?.attributes?.items) {
    return null;
  }
  
  const attr = customerData.attributes.items.find(
    a => a.name === attributeName
  );
  
  return attr?.value || null;
}

/**
 * Extract user email from subscriber attributes
 */
function getUserEmail(subscriberAttributes) {
  return subscriberAttributes.$email?.value || null;
}

/**
 * Extract custom attributes
 */
function getCustomAttribute(subscriberAttributes, key) {
  return subscriberAttributes[key]?.value || null;
}

// ==========================================
// EXPRESS.JS EXAMPLE
// ==========================================

// const express = require('express');
// const app = express();
// 
// app.use(express.json());
// 
// app.post('/webhooks/revenuecat', handleRevenueCatWebhook);
// 
// app.listen(3000, () => {
//   console.log('Webhook server running on port 3000');
// });

// ==========================================
// NEXT.JS API ROUTE EXAMPLE
// ==========================================

// // pages/api/webhooks/revenuecat.js
// export default async function handler(req, res) {
//   if (req.method !== 'POST') {
//     return res.status(405).json({ error: 'Method not allowed' });
//   }
//   
//   return handleRevenueCatWebhook(req, res);
// }

module.exports = {
  handleRevenueCatWebhook,
  validateAuthorization,
  
  // V1 API
  fetchSubscriberData,
  
  // V2 API
  fetchCustomerDataV2,
  verifyAndSyncSubscriptionStatus,
  getSubscriptionStatusFromDB,
  syncDatabaseWithRevenueCat,
  hasActiveEntitlementV2,
  getActiveEntitlementIdsV2,
  getCustomerEmailV2,
  getCustomerDisplayNameV2,
  getCustomerAttributeV2,
  shouldVerifyWithRevenueCat,
  
  // Entitlement Management
  extractEntitlementData,
  extractEntitlementsFromEvent,
  syncEntitlementsToDatabase,
  syncEntitlementsToNormalizedTable,
  getUserEntitlements,
  userHasEntitlement,
  
  // Helper functions (V1/Webhook format)
  hasActiveEntitlement,
  getActiveEntitlementIds,
  getUserEmail,
  getCustomAttribute
};

// .env file
REVENUECAT_WEBHOOK_SECRET=MYSECRET
REVENUECAT_API_KEY=your_api_key_here

-- Track processed events (idempotency)
CREATE TABLE processed_webhook_events (
  event_id VARCHAR(255) PRIMARY KEY,
  event_type VARCHAR(100) NOT NULL,
  app_user_id VARCHAR(255) NOT NULL,
  environment VARCHAR(20), -- PRODUCTION or SANDBOX
  processed_at TIMESTAMP DEFAULT NOW(),
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX idx_app_user_id ON processed_webhook_events(app_user_id);
CREATE INDEX idx_processed_at ON processed_webhook_events(processed_at);
CREATE INDEX idx_event_type ON processed_webhook_events(event_type);

-- User subscriptions table
CREATE TABLE user_subscriptions (
  id SERIAL PRIMARY KEY,
  app_user_id VARCHAR(255) UNIQUE NOT NULL,
  external_user_id VARCHAR(255),
  email VARCHAR(255),
  
  -- Subscription status
  is_active BOOLEAN DEFAULT false,
  subscription_status VARCHAR(50), -- active, cancelled, expired, trial, paused
  product_id VARCHAR(255),
  entitlements JSONB, -- Store active entitlements as JSON
  
  -- Dates
  expires_at TIMESTAMP,
  purchased_at TIMESTAMP,
  cancelled_at TIMESTAMP,
  trial_end_at TIMESTAMP,
  
  -- Flags
  auto_renew BOOLEAN DEFAULT true,
  billing_issue BOOLEAN DEFAULT false,
  
  -- Metadata
  store VARCHAR(50), -- app_store, play_store, stripe, etc
  environment VARCHAR(20), -- PRODUCTION or SANDBOX
  
  -- Tracking
  last_webhook_event_id VARCHAR(255),
  last_webhook_event_type VARCHAR(100),
  last_revenuecat_sync_at TIMESTAMP,
  last_updated TIMESTAMP DEFAULT NOW(),
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX idx_external_user_id ON user_subscriptions(external_user_id);
CREATE INDEX idx_email ON user_subscriptions(email);
CREATE INDEX idx_subscription_status ON user_subscriptions(subscription_status);
CREATE INDEX idx_is_active ON user_subscriptions(is_active);
CREATE INDEX idx_expires_at ON user_subscriptions(expires_at);

-- Dedicated entitlements table (normalized approach)
CREATE TABLE user_entitlements (
  id SERIAL PRIMARY KEY,
  app_user_id VARCHAR(255) NOT NULL,
  entitlement_id VARCHAR(255) NOT NULL,
  product_id VARCHAR(255) NOT NULL,
  
  -- Status
  is_active BOOLEAN DEFAULT true,
  
  -- Dates
  granted_at TIMESTAMP DEFAULT NOW(),
  expires_at TIMESTAMP,
  grace_period_expires_at TIMESTAMP,
  purchase_date TIMESTAMP,
  
  -- Metadata
  store VARCHAR(50),
  environment VARCHAR(20),
  
  -- Tracking
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW(),
  
  UNIQUE(app_user_id, entitlement_id)
);

CREATE INDEX idx_entitlement_user ON user_entitlements(app_user_id);
CREATE INDEX idx_entitlement_id ON user_entitlements(entitlement_id);
CREATE INDEX idx_entitlement_active ON user_entitlements(is_active);
CREATE INDEX idx_entitlement_expires ON user_entitlements(expires_at);

-- Track RevenueCat API calls for monitoring
CREATE TABLE revenuecat_api_calls (
  id SERIAL PRIMARY KEY,
  endpoint VARCHAR(255) NOT NULL, -- v1/subscribers or v2/customers
  app_user_id VARCHAR(255),
  status_code INTEGER,
  response_time_ms INTEGER,
  error_message TEXT,
  called_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX idx_api_endpoint ON revenuecat_api_calls(endpoint);
CREATE INDEX idx_api_user ON revenuecat_api_calls(app_user_id);
CREATE INDEX idx_api_called_at ON revenuecat_api_calls(called_at);

-- Webhook delivery failures (for retry logic)
CREATE TABLE webhook_failures (
  id SERIAL PRIMARY KEY,
  event_id VARCHAR(255) NOT NULL,
  event_type VARCHAR(100) NOT NULL,
  app_user_id VARCHAR(255) NOT NULL,
  error_message TEXT,
  retry_count INTEGER DEFAULT 0,
  next_retry_at TIMESTAMP,
  created_at TIMESTAMP DEFAULT NOW(),
  resolved_at TIMESTAMP
);

CREATE INDEX idx_webhook_failures_user ON webhook_failures(app_user_id);
CREATE INDEX idx_webhook_failures_retry ON webhook_failures(next_retry_at);

/**
 * Sync entitlements to normalized table
 * Recommended for complex entitlement logic
 */
async function syncEntitlementsToNormalizedTable(appUserId, activeEntitlements, event) {
  // Get all entitlement IDs from event
  const entitlementIds = Object.keys(activeEntitlements);
  
  // Mark all existing entitlements as inactive first
  await db.query(`
    UPDATE user_entitlements 
    SET is_active = false, updated_at = NOW()
    WHERE app_user_id = $1
  `, [appUserId]);
  
  // Insert or update each active entitlement
  for (const entitlementId of entitlementIds) {
    const ent = activeEntitlements[entitlementId];
    
    await db.query(`
      INSERT INTO user_entitlements (
        app_user_id,
        entitlement_id,
        product_id,
        is_active,
        expires_at,
        grace_period_expires_at,
        purchase_date,
        store,
        environment,
        updated_at
      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW())
      ON CONFLICT (app_user_id, entitlement_id)
      DO UPDATE SET
        product_id = EXCLUDED.product_id,
        is_active = EXCLUDED.is_active,
        expires_at = EXCLUDED.expires_at,
        grace_period_expires_at = EXCLUDED.grace_period_expires_at,
        purchase_date = EXCLUDED.purchase_date,
        store = EXCLUDED.store,
        environment = EXCLUDED.environment,
        updated_at = NOW()
    `, [
      appUserId,
      entitlementId,
      ent.product_id,
      true,
      ent.expires_at ? new Date(ent.expires_at) : null,
      ent.grace_period_expires_at ? new Date(ent.grace_period_expires_at) : null,
      ent.purchase_date ? new Date(ent.purchase_date) : null,
      event.store,
      event.environment
    ]);
  }
}

/**
 * Get user's active entitlements from database
 */
async function getUserEntitlements(appUserId) {
  const result = await db.query(`
    SELECT 
      entitlement_id,
      product_id,
      expires_at,
      grace_period_expires_at,
      purchase_date,
      is_active
    FROM user_entitlements
    WHERE app_user_id = $1 
      AND is_active = true
      AND (expires_at IS NULL OR expires_at > NOW())
    ORDER BY purchase_date DESC
  `, [appUserId]);
  
  // Convert to object format
  const entitlements = {};
  result.rows.forEach(row => {
    entitlements[row.entitlement_id] = {
      product_id: row.product_id,
      expires_at: row.expires_at,
      grace_period_expires_at: row.grace_period_expires_at,
      purchase_date: row.purchase_date
    };
  });
  
  return entitlements;
}

/**
 * Check if user has specific entitlement
 */
async function userHasEntitlement(appUserId, entitlementId) {
  const result = await db.query(`
    SELECT 1 FROM user_entitlements
    WHERE app_user_id = $1 
      AND entitlement_id = $2
      AND is_active = true
      AND (expires_at IS NULL OR expires_at > NOW())
    LIMIT 1
  `, [appUserId, entitlementId]);
  
  return result.rows.length > 0;
}

# RevenueCat Configuration
REVENUECAT_API_KEY=your_secret_api_key_here
REVENUECAT_PROJECT_ID=your_project_id_here
REVENUECAT_WEBHOOK_SECRET=MYSECRET

# Database Configuration
DATABASE_URL=postgresql://user:password@localhost:5432/dbname

# Application Configuration
NODE_ENV=production
PORT=3000

# Optional: Rate Limiting
REVENUECAT_API_RATE_LIMIT=480
REVENUECAT_API_RATE_WINDOW=60000

# Optional: Caching
CACHE_TTL_SECONDS=3600
ENABLE_REVENUECAT_CACHE=true

# Optional: Monitoring
ENABLE_API_CALL_TRACKING=true
ENABLE_WEBHOOK_FAILURE_TRACKING=true

# .gitignore
.env
.env.local
.env.*.local

.env.development
.env.staging
.env.production

// config/env.js
const requiredEnvVars = [
  'REVENUECAT_API_KEY',
  'REVENUECAT_PROJECT_ID',
  'REVENUECAT_WEBHOOK_SECRET',
  'DATABASE_URL'
];

function validateEnvironment() {
  const missing = requiredEnvVars.filter(key => !process.env[key]);
  
  if (missing.length > 0) {
    throw new Error(
      `Missing required environment variables: ${missing.join(', ')}`
    );
  }
  
  console.log('Environment variables validated');
}

validateEnvironment();

// Never skip authorization validation
if (!validateAuthorization(req)) {
  return res.status(401).json({ error: 'Unauthorized' });
}

// Respond within 60 seconds
// Defer heavy processing to background jobs
await queueBackgroundJob('process-webhook', event);
return res.status(200).json({ message: 'Accepted' });

// Implement idempotency using event.id
const isDuplicate = await checkDuplicateEvent(event.id);
if (isDuplicate) {
  return res.status(200).json({ message: 'Already processed' });
}

// Validate required fields
if (!event || !event.type || !event.app_user_id) {
  return res.status(400).json({ error: 'Invalid event structure' });
}

// The environment field will be "SANDBOX"
if (event.environment === 'SANDBOX') {
  console.log('Test purchase - skip production workflows');
}

async function syncSubscriptionStatus(appUserId, event) {
  const activeEntitlements = event.entitlements || {};
  const hasActiveSubscription = Object.keys(activeEntitlements).length > 0;
  
  await db.query(`
    UPDATE user_subscriptions 
    SET subscription_status = $1,
        entitlements = $2,
        expires_at = $3,
        last_updated = NOW()
    WHERE app_user_id = $4
  `, [
    hasActiveSubscription ? 'active' : 'expired',
    JSON.stringify(activeEntitlements),
    event.expiration_at_ms ? new Date(event.expiration_at_ms) : null,
    appUserId
  ]);
}

async function sendCancellationEmail(email, data) {
  // Use your email service
  await emailService.send({
    to: email,
    template: 'subscription-cancelled',
    data: {
      userName: data.externalUserId,
      expirationDate: new Date(data.expirationDate).toLocaleDateString(),
      feedbackUrl: 'https://yourapp.com/feedback'
    }
  });
}

async function trackWebhookEvent(eventType, userId, data) {
  await analytics.track({
    userId,
    event: `Subscription ${eventType}`,
    properties: {
      productId: data.productId,
      price: data.price,
      currency: data.currency,
      environment: data.environment
    }
  });
}

GET https://api.revenuecat.com/v1/subscribers/{app_user_id}

curl -X GET "https://api.revenuecat.com/v1/subscribers/user_abc123" \
  -H "Authorization: Bearer YOUR_REVENUECAT_API_KEY" \
  -H "Content-Type: application/json"

{
  "request_date": "2025-01-17T12:00:00Z",
  "request_date_ms": 1737115200000,
  "subscriber": {
    "original_app_user_id": "user_abc123",
    "original_application_version": "1.0",
    "first_seen": "2024-01-01T00:00:00Z",
    "last_seen": "2025-01-17T10:00:00Z",
    "management_url": "https://apps.apple.com/account/subscriptions",
    "original_purchase_date": "2024-01-15T12:00:00Z",
    "non_subscriptions": {},
    "subscriptions": {
      "yearly_pro": {
        "auto_resume_date": null,
        "billing_issues_detected_at": null,
        "expires_date": "2025-02-15T12:00:00Z",
        "grace_period_expires_date": null,
        "is_sandbox": false,
        "original_purchase_date": "2024-02-15T12:00:00Z",
        "ownership_type": "PURCHASED",
        "period_type": "normal",
        "purchase_date": "2025-01-15T12:00:00Z",
        "refunded_at": null,
        "store": "app_store",
        "unsubscribe_detected_at": null
      }
    },
    "entitlements": {
      "pro": {
        "expires_date": "2025-02-15T12:00:00Z",
        "grace_period_expires_date": null,
        "product_identifier": "yearly_pro",
        "purchase_date": "2025-01-15T12:00:00Z"
      }
    },
    "subscriber_attributes": {
      "$email": {
        "value": "[email protected]",
        "updated_at_ms": 1737115200000
      },
      "$displayName": {
        "value": "John Doe",
        "updated_at_ms": 1737115200000
      }
    }
  }
}

async function getSubscriberV1(appUserId) {
  const response = await fetch(
    `https://api.revenuecat.com/v1/subscribers/${appUserId}`,
    {
      headers: {
        'Authorization': `Bearer ${REVENUECAT_API_KEY}`,
        'Content-Type': 'application/json'
      }
    }
  );
  
  if (!response.ok) {
    throw new Error(`RevenueCat V1 API error: ${response.status}`);
  }
  
  const data = await response.json();
  return data.subscriber;
}