Designing a Unified Mobile Revenue Funnel with Antigravity: AdMob, IAP, and Subscriptions for Indie Developers

# agents.md
 
## Revenue Dashboard Integration
 
### Goal
Unified view of AdMob + RevenueCat + Firebase Analytics revenue data.
Real-time aggregation with 15-minute maximum latency.
 
### Architecture
- iOS (Swift/SwiftUI) — client-side ad tracking, RevenueCat SDK
- Android (Kotlin) — client-side ad tracking, RevenueCat SDK  
- Firebase Functions — webhook receiver, daily aggregation, alerting
- Firestore — aggregated revenue documents, event log
 
### Data Sources
- RevenueCat: Webhook for real-time events + REST API for historical
- AdMob: Client-side GADAdValue events → Firestore write
- Firebase Analytics: ad_impression events for behavioral analysis
 
### Key Constraints
- No PII in revenue aggregation documents
- Sandbox/test events must never reach production aggregates
- Firebase Functions use Secret Manager for all API keys

// functions/src/revenueCollector.ts
 
import { onRequest, onSchedule } from "firebase-functions/v2/https";
import { getFirestore } from "firebase-admin/firestore";
import { defineSecret } from "firebase-functions/params";
import * as logger from "firebase-functions/logger";
 
const revenueCatApiKey = defineSecret("REVENUECAT_API_KEY");
 
interface DailyRevenueDoc {
  date: string;
  admobRevenue: number;
  iapRevenue: number;
  subscriptionRevenue: number;
  totalRevenue: number;
  activeSubscribers: number;
  newSubscribers: number;
  churnedSubscribers: number;
  updatedAt: Date;
}
 
interface RevenueEvent {
  eventType: string;
  userId: string;
  revenue: number;
  productId: string;
  isSubscription: boolean;
  environment: string;
  timestamp: Date;
}
 
// RevenueCat webhook receiver
export const revenueCatWebhook = onRequest(
  { secrets: [revenueCatApiKey] },
  async (req, res) => {
    const db = getFirestore();
 
    try {
      const event = req.body;
      const eventType: string = event.event?.type;
      const environment: string = event.event?.environment;
 
      // Hard filter: sandbox events never touch production data
      if (environment !== "PRODUCTION") {
        logger.info(`Sandbox event skipped: ${eventType}`);
        res.status(200).json({ status: "sandbox_skipped" });
        return;
      }
 
      const revenue: number = event.event?.price_in_purchased_currency ?? 0;
      const productId: string = event.event?.product_id ?? "";
      const isSubscription: boolean = event.event?.period_type !== undefined;
      const userId: string = event.event?.app_user_id;
 
      // Log raw event for debugging and audit trail
      const revenueEvent: RevenueEvent = {
        eventType,
        userId,
        revenue,
        productId,
        isSubscription,
        environment,
        timestamp: new Date(),
      };
 
      await db.collection("revenue_events").add(revenueEvent);
 
      // Update daily aggregate atomically
      await updateDailyAggregate(
        db,
        new Date(),
        revenue,
        isSubscription,
        eventType
      );
 
      logger.info(`Revenue event processed: ${eventType}, $${revenue}`);
      res.status(200).json({ status: "ok" });
    } catch (error) {
      logger.error("Webhook processing failed:", error);
      res.status(500).json({ error: "Internal server error" });
    }
  }
);
 
async function updateDailyAggregate(
  db: FirebaseFirestore.Firestore,
  date: Date,
  revenue: number,
  isSubscription: boolean,
  eventType: string
): Promise<void> {
  const dateKey = date.toISOString().split("T")[0];
  const docRef = db.collection("daily_revenue").doc(dateKey);
 
  await db.runTransaction(async (transaction) => {
    const doc = await transaction.get(docRef);
    const current = doc.exists ? (doc.data() as DailyRevenueDoc) : null;
 
    const iapDelta = !isSubscription ? revenue : 0;
    const subDelta = isSubscription && eventType === "INITIAL_PURCHASE" ? revenue : 0;
    const renewalDelta = isSubscription && eventType === "RENEWAL" ? revenue : 0;
    const newSubDelta = eventType === "INITIAL_PURCHASE" && isSubscription ? 1 : 0;
    const churnDelta = eventType === "CANCELLATION" ? 1 : 0;
 
    const update: Partial<DailyRevenueDoc> = {
      date: dateKey,
      iapRevenue: (current?.iapRevenue ?? 0) + iapDelta,
      subscriptionRevenue:
        (current?.subscriptionRevenue ?? 0) + subDelta + renewalDelta,
      newSubscribers: (current?.newSubscribers ?? 0) + newSubDelta,
      churnedSubscribers: (current?.churnedSubscribers ?? 0) + churnDelta,
      updatedAt: new Date(),
    };
 
    // Calculate total (admobRevenue is added separately from client events)
    const newIap = update.iapRevenue ?? 0;
    const newSub = update.subscriptionRevenue ?? 0;
    const currentAdmob = current?.admobRevenue ?? 0;
    update.totalRevenue = currentAdmob + newIap + newSub;
 
    transaction.set(docRef, update, { merge: true });
  });
}

// AdRevenueTracker.swift
import GoogleMobileAds
import FirebaseAnalytics
import FirebaseFirestore
import FirebaseAuth
 
final class AdRevenueTracker {
  static let shared = AdRevenueTracker()
  private let db = Firestore.firestore()
  private init() {}
  
  /// Call this from your ad delegate's adDidRecordImpression method
  func recordImpression(adValue: GADAdValue, adUnitId: String, adType: AdType) {
    let revenue = adValue.value.doubleValue
    let currency = adValue.currencyCode
    
    // Firebase Analytics — for aggregate reporting in GA4
    Analytics.logEvent("ad_impression", parameters: [
      AnalyticsParameterValue: revenue,
      AnalyticsParameterCurrency: currency,
      "ad_unit_id": adUnitId,
      "ad_type": adType.rawValue,
      "ad_platform": "admob",
    ])
    
    // Firestore — for user-level LTV calculation
    let data: [String: Any] = [
      "value": revenue,
      "currency": currency,
      "adUnitId": adUnitId,
      "adType": adType.rawValue,
      "timestamp": Timestamp(date: Date()),
      "userId": Auth.auth().currentUser?.uid ?? "anonymous",
    ]
    
    // Non-blocking write — failure here must never affect user experience
    db.collection("ad_impressions").addDocument(data: data) { error in
      if let error = error {
        // Log but don't surface to user
        print("[AdRevenueTracker] Write failed: \(error.localizedDescription)")
      }
    }
    
    // Also update the daily aggregate in Firestore for the dashboard
    updateDailyAdRevenue(revenue: revenue)
  }
  
  private func updateDailyAdRevenue(revenue: Double) {
    let dateKey = ISO8601DateFormatter().string(from: Date()).prefix(10).description
    let docRef = db.collection("daily_revenue").document(dateKey)
    
    docRef.setData([
      "admobRevenue": FieldValue.increment(revenue),
      "totalRevenue": FieldValue.increment(revenue),
      "date": dateKey,
    ], merge: true)
  }
  
  enum AdType: String {
    case banner = "banner"
    case interstitial = "interstitial"
    case rewarded = "rewarded"
    case rewardedInterstitial = "rewarded_interstitial"
    case nativeAdvanced = "native_advanced"
  }
}

// Usage in your ad delegate
class InterstitialAdDelegate: NSObject, GADFullScreenContentDelegate {
  func adDidRecordImpression(_ ad: GADFullScreenPresentingAd) {
    guard let adValue = (ad as? GADAdValue) else { return }
    AdRevenueTracker.shared.recordImpression(
      adValue: adValue,
      adUnitId: "ca-app-pub-YOUR_ID/YOUR_UNIT_ID",
      adType: .interstitial
    )
  }
}

// AdRevenueTracker.kt
import android.os.Bundle
import com.google.android.gms.ads.AdValue
import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.firestore.FieldValue
import com.google.firebase.firestore.FirebaseFirestore
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
 
class AdRevenueTracker private constructor(
  private val analytics: FirebaseAnalytics,
  private val db: FirebaseFirestore
) {
  private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
  
  enum class AdType(val value: String) {
    BANNER("banner"),
    INTERSTITIAL("interstitial"),
    REWARDED("rewarded"),
    NATIVE("native_advanced")
  }
  
  fun recordImpression(adValue: AdValue, adUnitId: String, adType: AdType) {
    val revenueUsd = adValue.valueMicros / 1_000_000.0
    
    // Firebase Analytics
    analytics.logEvent("ad_impression", Bundle().apply {
      putDouble(FirebaseAnalytics.Param.VALUE, revenueUsd)
      putString(FirebaseAnalytics.Param.CURRENCY, adValue.currencyCode)
      putString("ad_unit_id", adUnitId)
      putString("ad_type", adType.value)
      putString("ad_platform", "admob")
    })
    
    // Non-blocking Firestore write
    scope.launch {
      try {
        val dateKey = SimpleDateFormat("yyyy-MM-dd", Locale.US).format(Date())
        
        // User-level event log
        db.collection("ad_impressions").add(hashMapOf(
          "value" to revenueUsd,
          "currency" to adValue.currencyCode,
          "adUnitId" to adUnitId,
          "adType" to adType.value,
          "timestamp" to com.google.firebase.Timestamp.now(),
        ))
        
        // Daily aggregate update
        db.collection("daily_revenue").document(dateKey).set(
          hashMapOf(
            "admobRevenue" to FieldValue.increment(revenueUsd),
            "totalRevenue" to FieldValue.increment(revenueUsd),
            "date" to dateKey,
          ),
          com.google.firebase.firestore.SetOptions.merge()
        )
      } catch (e: Exception) {
        // Swallow — never let tracking failures surface to users
      }
    }
  }
  
  companion object {
    @Volatile
    private var instance: AdRevenueTracker? = null
    
    fun getInstance(analytics: FirebaseAnalytics): AdRevenueTracker {
      return instance ?: synchronized(this) {
        instance ?: AdRevenueTracker(analytics, FirebaseFirestore.getInstance())
          .also { instance = it }
      }
    }
  }
}

// MonetizationManager.swift
import FirebaseRemoteConfig
import RevenueCat
 
enum MonetizationModel: Equatable {
  case adSupported           // New users: light ads, no purchase prompts
  case hybridAdsIap          // Retained users: ads + IAP options shown
  case subscriptionFocused   // Power users: subscription front and center
  case premiumOnly           // Subscribers: no ads, full access
}
 
@MainActor
final class MonetizationManager: ObservableObject {
  @Published private(set) var model: MonetizationModel = .adSupported
  
  static let shared = MonetizationManager()
  private init() {}
  
  func refresh() async {
    // Paying subscribers always get the premium experience
    if await hasActiveSubscription() {
      model = .premiumOnly
      return
    }
    
    let days = daysInstalled()
    let engagement = engagementScore()
    
    // Remote Config drives the rules — change strategy without shipping builds
    let remoteConfig = RemoteConfig.remoteConfig()
    let rulesJson = remoteConfig.configValue(forKey: "monetization_rules").stringValue ?? ""
    
    model = resolveModel(json: rulesJson, days: days, engagement: engagement)
  }
  
  private func hasActiveSubscription() async -> Bool {
    guard let info = try? await Purchases.shared.customerInfo() else { return false }
    return info.entitlements.active["premium"] != nil
  }
  
  private func daysInstalled() -> Int {
    let defaults = UserDefaults.standard
    let key = "app_first_launch"
    if defaults.object(forKey: key) == nil {
      defaults.set(Date(), forKey: key)
      return 0
    }
    let firstLaunch = defaults.object(forKey: key) as? Date ?? Date()
    return Calendar.current.dateComponents([.day], from: firstLaunch, to: Date()).day ?? 0
  }
  
  private func engagementScore() -> Double {
    let defaults = UserDefaults.standard
    let sessions = Double(defaults.integer(forKey: "total_sessions"))
    let avgDuration = defaults.double(forKey: "avg_session_seconds") / 60.0
    return min(sessions * 0.1 + avgDuration * 0.5, 10.0)
  }
  
  private func resolveModel(json: String, days: Int, engagement: Double) -> MonetizationModel {
    // Parse Remote Config rules, fall back to defaults if parsing fails
    struct Rule: Decodable {
      let maxDays: Int?
      let minDays: Int?
      let maxEngagement: Double?
      let model: String
    }
    
    if let data = json.data(using: .utf8),
       let rules = try? JSONDecoder().decode([Rule].self, from: data) {
      for rule in rules {
        let meetsMinDays = rule.minDays.map { days >= $0 } ?? true
        let meetsMaxDays = rule.maxDays.map { days < $0 } ?? true
        let meetsEngagement = rule.maxEngagement.map { engagement < $0 } ?? true
        
        if meetsMinDays && meetsMaxDays && meetsEngagement {
          switch rule.model {
          case "ad_supported": return .adSupported
          case "hybrid_ads_iap": return .hybridAdsIap
          case "subscription_focused": return .subscriptionFocused
          default: continue
          }
        }
      }
    }
    
    // Hardcoded fallback — always safe, never wrong
    if days < 3 { return .adSupported }
    if days < 14 && engagement < 5.0 { return .hybridAdsIap }
    return .subscriptionFocused
  }
}

[
  { "maxDays": 3, "model": "ad_supported" },
  { "minDays": 3, "maxDays": 14, "maxEngagement": 5.0, "model": "hybrid_ads_iap" },
  { "minDays": 14, "model": "subscription_focused" },
  { "minDays": 3, "model": "subscription_focused" }
]

# revenue_analytics.py
import requests
from datetime import datetime, timedelta
from typing import Optional
 
def calculate_price_elasticity(
    api_key: str,
    product_id: str,
    price_change_date: str,
    old_price: float,
    new_price: float,
    comparison_days: int = 30
) -> dict:
    """
    Measure revenue impact of a price change by comparing purchase rates
    before and after.
    
    Elasticity < -1: Elastic — lowering price could increase total revenue
    Elasticity > -1: Inelastic — raising price could increase total revenue
    Elasticity = -1: Unit elastic — price has no net revenue impact
    """
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    change_date = datetime.strptime(price_change_date, "%Y-%m-%d")
    
    before_start = change_date - timedelta(days=comparison_days)
    before_end = change_date
    after_start = change_date
    after_end = change_date + timedelta(days=comparison_days)
    
    def fetch_purchases(start: datetime, end: datetime) -> Optional[int]:
        params = {
            "start_date": start.strftime("%Y-%m-%d"),
            "end_date": end.strftime("%Y-%m-%d"),
            "product_identifier": product_id,
        }
        try:
            response = requests.get(
                "https://api.revenuecat.com/v1/charts/overview",
                headers=headers,
                params=params,
                timeout=10
            )
            response.raise_for_status()
            return response.json().get("metrics", {}).get("initial_purchases")
        except requests.RequestException as e:
            print(f"API request failed: {e}")
            return None
    
    purchases_before = fetch_purchases(before_start, before_end)
    purchases_after = fetch_purchases(after_start, after_end)
    
    if purchases_before is None or purchases_after is None:
        return {"error": "Failed to fetch purchase data from RevenueCat"}
    
    if purchases_before == 0:
        return {"error": "No purchases in the before period — need more data"}
    
    purchase_change = (purchases_after - purchases_before) / purchases_before
    price_change = (new_price - old_price) / old_price
    
    if price_change == 0:
        return {"error": "No price change between old_price and new_price"}
    
    elasticity = purchase_change / price_change
    
    revenue_before = purchases_before * old_price
    revenue_after = purchases_after * new_price
    revenue_delta = revenue_after - revenue_before
    revenue_change_rate = revenue_delta / revenue_before if revenue_before > 0 else 0
    
    if elasticity < -1.5:
        recommendation = f"Strong evidence to lower price further (to ~${old_price * 0.7:.2f})"
    elif -1.5 <= elasticity < -1:
        recommendation = f"Consider a modest price reduction (to ~${new_price * 0.9:.2f})"
    elif -1 <= elasticity < -0.5:
        recommendation = "Price appears near optimal — small changes likely neutral"
    else:
        recommendation = f"Inelastic demand — consider raising price to ~${new_price * 1.2:.2f}"
    
    return {
        "product_id": product_id,
        "price_change_date": price_change_date,
        "old_price": f"${old_price:.2f}",
        "new_price": f"${new_price:.2f}",
        "price_change": f"{price_change:.1%}",
        "purchases_before": purchases_before,
        "purchases_after": purchases_after,
        "purchase_change": f"{purchase_change:.1%}",
        "elasticity": round(elasticity, 2),
        "revenue_before": f"${revenue_before:.2f}",
        "revenue_after": f"${revenue_after:.2f}",
        "revenue_impact": f"{revenue_change_rate:+.1%} (${revenue_delta:+.2f})",
        "recommendation": recommendation
    }
 
 
if __name__ == "__main__":
    result = calculate_price_elasticity(
        api_key="YOUR_REVENUECAT_API_KEY",
        product_id="com.yourapp.premium_monthly",
        price_change_date="2026-04-01",
        old_price=4.99,
        new_price=2.99,
        comparison_days=30
    )
    import json
    print(json.dumps(result, indent=2))

// functions/src/revenueMonitor.ts
import { onSchedule } from "firebase-functions/v2/scheduler";
import { getFirestore } from "firebase-admin/firestore";
import * as logger from "firebase-functions/logger";
 
export const dailyRevenueMonitor = onSchedule("0 9 * * *", async () => {
  const db = getFirestore();
  
  const today = formatDate(new Date());
  const yesterday = formatDate(new Date(Date.now() - 86_400_000));
  const sevenDaysAgo = formatDate(new Date(Date.now() - 7 * 86_400_000));
  
  const [todayDoc, yesterdayDoc] = await Promise.all([
    db.collection("daily_revenue").doc(today).get(),
    db.collection("daily_revenue").doc(yesterday).get(),
  ]);
  
  const todayRevenue = todayDoc.data()?.totalRevenue ?? 0;
  const yesterdayRevenue = yesterdayDoc.data()?.totalRevenue ?? 0;
  
  // 7-day rolling average for baseline
  const weekDocs = await db
    .collection("daily_revenue")
    .where("date", ">=", sevenDaysAgo)
    .where("date", "<", today)
    .get();
  
  const weeklyAvg =
    weekDocs.docs.length > 0
      ? weekDocs.docs.reduce((sum, doc) => sum + (doc.data().totalRevenue ?? 0), 0) /
        weekDocs.docs.length
      : yesterdayRevenue;
  
  const vsYesterday =
    yesterdayRevenue > 0
      ? (todayRevenue - yesterdayRevenue) / yesterdayRevenue
      : 0;
  
  const vsAverage =
    weeklyAvg > 0 ? (todayRevenue - weeklyAvg) / weeklyAvg : 0;
  
  const alerts: string[] = [];
  
  if (vsYesterday < -0.3) {
    alerts.push(
      `⚠️ Revenue drop: ${(vsYesterday * 100).toFixed(1)}% vs yesterday\n` +
        `  Yesterday: $${yesterdayRevenue.toFixed(2)} → Today: $${todayRevenue.toFixed(2)}`
    );
  }
  
  if (vsAverage < -0.4) {
    alerts.push(
      `⚠️ Revenue 40%+ below 7-day average ($${weeklyAvg.toFixed(2)})\n` +
        `  Today: $${todayRevenue.toFixed(2)}`
    );
  }
  
  // Monthly goal pacing
  const MONTHLY_GOAL = parseFloat(process.env.MONTHLY_REVENUE_GOAL ?? "1000");
  const now = new Date();
  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
  const dayOfMonth = now.getDate();
  const expectedRevenue = (dayOfMonth / daysInMonth) * MONTHLY_GOAL;
  
  const monthStart = today.substring(0, 7) + "-01";
  const monthDocs = await db
    .collection("daily_revenue")
    .where("date", ">=", monthStart)
    .where("date", "<=", today)
    .get();
  
  const monthlyRevenue = monthDocs.docs.reduce(
    (sum, doc) => sum + (doc.data().totalRevenue ?? 0),
    0
  );
  
  const paceRate = monthlyRevenue / expectedRevenue;
  
  if (paceRate < 0.7) {
    alerts.push(
      `📊 Monthly pace at ${(paceRate * 100).toFixed(0)}% of target\n` +
        `  Current: $${monthlyRevenue.toFixed(2)} / Expected: $${expectedRevenue.toFixed(2)}\n` +
        `  Goal: $${MONTHLY_GOAL}`
    );
  }
  
  if (alerts.length > 0) {
    await sendSlackAlert(alerts.join("\n\n"));
    logger.warn("Revenue alerts sent", { alertCount: alerts.length });
  } else {
    logger.info("Revenue check passed", {
      todayRevenue,
      vsYesterday: `${(vsYesterday * 100).toFixed(1)}%`,
      monthlyPace: `${(paceRate * 100).toFixed(0)}%`,
    });
  }
});
 
function formatDate(date: Date): string {
  return date.toISOString().split("T")[0];
}
 
async function sendSlackAlert(message: string): Promise<void> {
  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
  if (!webhookUrl) {
    logger.warn("SLACK_WEBHOOK_URL not configured — alert not sent");
    return;
  }
  
  const response = await fetch(webhookUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text: message }),
  });
  
  if (!response.ok) {
    logger.error("Slack notification failed", { status: response.status });
  }
}

// functions/src/subscriptionRetention.ts
import { onSchedule } from "firebase-functions/v2/scheduler";
import { getFirestore, Timestamp } from "firebase-admin/firestore";
import * as logger from "firebase-functions/logger";
 
interface SubscriberCohort {
  cohortMonth: string;          // "2026-01"
  initialSubscribers: number;
  retainedAt30Days: number;
  retainedAt60Days: number;
  retainedAt90Days: number;
  retentionRate30: number;
  retentionRate60: number;
  retentionRate90: number;
  avgRevenuePerSubscriber: number;
}
 
// Runs daily to update cohort retention metrics
export const updateRetentionMetrics = onSchedule("0 10 * * *", async () => {
  const db = getFirestore();
  
  // Pull all subscription events from last 120 days
  const cutoff = Timestamp.fromDate(new Date(Date.now() - 120 * 86_400_000));
  const eventsSnapshot = await db
    .collection("revenue_events")
    .where("isSubscription", "==", true)
    .where("timestamp", ">=", cutoff)
    .orderBy("timestamp", "asc")
    .get();
  
  // Group INITIAL_PURCHASE events by cohort month
  const cohortMap = new Map<string, Set<string>>();
  const cancellationMap = new Map<string, { userId: string; date: Date }[]>();
  
  for (const doc of eventsSnapshot.docs) {
    const data = doc.data();
    const eventDate = (data.timestamp as Timestamp).toDate();
    const cohortMonth = eventDate.toISOString().substring(0, 7);
    
    if (data.eventType === "INITIAL_PURCHASE") {
      if (!cohortMap.has(cohortMonth)) {
        cohortMap.set(cohortMonth, new Set());
      }
      cohortMap.get(cohortMonth)!.add(data.userId);
    } else if (data.eventType === "CANCELLATION") {
      if (!cancellationMap.has(data.userId)) {
        cancellationMap.set(data.userId, []);
      }
      cancellationMap.get(data.userId)!.push({ userId: data.userId, date: eventDate });
    }
  }
  
  // Calculate retention for each cohort
  const cohorts: SubscriberCohort[] = [];
  
  for (const [cohortMonth, subscribers] of cohortMap.entries()) {
    const cohortStart = new Date(cohortMonth + "-01");
    const now = new Date();
    const daysSinceCohortStart = Math.floor(
      (now.getTime() - cohortStart.getTime()) / 86_400_000
    );
    
    // Only compute metrics for cohorts old enough
    if (daysSinceCohortStart < 30) continue;
    
    let retained30 = 0;
    let retained60 = 0;
    let retained90 = 0;
    
    for (const userId of subscribers) {
      const cancellations = cancellationMap.get(userId) ?? [];
      const cancelledWithin30 = cancellations.some(c => {
        const daysSinceStart = (c.date.getTime() - cohortStart.getTime()) / 86_400_000;
        return daysSinceStart <= 30;
      });
      const cancelledWithin60 = cancellations.some(c => {
        const daysSinceStart = (c.date.getTime() - cohortStart.getTime()) / 86_400_000;
        return daysSinceStart <= 60;
      });
      const cancelledWithin90 = cancellations.some(c => {
        const daysSinceStart = (c.date.getTime() - cohortStart.getTime()) / 86_400_000;
        return daysSinceStart <= 90;
      });
      
      if (!cancelledWithin30) retained30++;
      if (!cancelledWithin60 && daysSinceCohortStart >= 60) retained60++;
      if (!cancelledWithin90 && daysSinceCohortStart >= 90) retained90++;
    }
    
    const total = subscribers.size;
    cohorts.push({
      cohortMonth,
      initialSubscribers: total,
      retainedAt30Days: retained30,
      retainedAt60Days: daysSinceCohortStart >= 60 ? retained60 : -1,
      retainedAt90Days: daysSinceCohortStart >= 90 ? retained90 : -1,
      retentionRate30: total > 0 ? retained30 / total : 0,
      retentionRate60: total > 0 && daysSinceCohortStart >= 60 ? retained60 / total : -1,
      retentionRate90: total > 0 && daysSinceCohortStart >= 90 ? retained90 / total : -1,
      avgRevenuePerSubscriber: 0, // Populated in a separate pass
    });
  }
  
  // Write cohort data to Firestore
  const batch = db.batch();
  for (const cohort of cohorts) {
    const docRef = db.collection("subscription_cohorts").doc(cohort.cohortMonth);
    batch.set(docRef, cohort, { merge: true });
  }
  await batch.commit();
  
  logger.info(`Retention metrics updated for ${cohorts.length} cohorts`);
});

// functions/src/churnRiskDetector.ts
import { onSchedule } from "firebase-functions/v2/scheduler";
import { getFirestore, Timestamp } from "firebase-admin/firestore";
 
export const detectChurnRisk = onSchedule("0 11 * * 0", async () => {
  // Run weekly — churn signals develop over days, not hours
  const db = getFirestore();
  
  const thirtyDaysAgo = Timestamp.fromDate(new Date(Date.now() - 30 * 86_400_000));
  const sevenDaysAgo = Timestamp.fromDate(new Date(Date.now() - 7 * 86_400_000));
  
  // Get active subscribers
  const activeSubsSnapshot = await db
    .collection("revenue_events")
    .where("eventType", "==", "INITIAL_PURCHASE")
    .where("isSubscription", "==", true)
    .where("timestamp", ">=", thirtyDaysAgo)
    .get();
  
  const activeUserIds = new Set(activeSubsSnapshot.docs.map(d => d.data().userId));
  
  // Check session activity for each subscriber
  const atRiskUsers: string[] = [];
  
  for (const userId of activeUserIds) {
    const recentSessionsSnapshot = await db
      .collection("user_sessions")
      .where("userId", "==", userId)
      .where("timestamp", ">=", sevenDaysAgo)
      .get();
    
    const recentSessionCount = recentSessionsSnapshot.size;
    
    // Subscribers with less than 1 session in the last 7 days are at risk
    if (recentSessionCount < 1) {
      atRiskUsers.push(userId);
    }
  }
  
  // Write at-risk list to Firestore for use in push notification campaigns
  if (atRiskUsers.length > 0) {
    await db.collection("churn_risk").doc("latest").set({
      userIds: atRiskUsers,
      detectedAt: Timestamp.now(),
      count: atRiskUsers.length,
    });
  }
});