Rork × RevenueCat + Stripe Web 統合ガイド：iOS・Android・Web のサブスクリプションを1つのバックエンドで管理する

// src/hooks/useEntitlements.ts
import { useEffect, useState } from 'react';
import Purchases, { CustomerInfo } from 'react-native-purchases';
 
const REVENUECAT_API_KEY_IOS = 'appl_xxxxxxxxxxxxxxxx';
const REVENUECAT_API_KEY_ANDROID = 'goog_xxxxxxxxxxxxxxxx';
 
export function useEntitlements() {
  const [isPro, setIsPro] = useState(false);
  const [isLoading, setIsLoading] = useState(true);
  const [customerInfo, setCustomerInfo] = useState<CustomerInfo | null>(null);
 
  useEffect(() => {
    // プラットフォームに応じた API Key でセットアップ
    const apiKey = Platform.OS === 'ios'
      ? REVENUECAT_API_KEY_IOS
      : REVENUECAT_API_KEY_ANDROID;
 
    Purchases.configure({ apiKey });
 
    // 現在のカスタマー情報を取得
    Purchases.getCustomerInfo()
      .then((info) => {
        setCustomerInfo(info);
        // 'pro' エンタイトルメントが有効かを確認
        setIsPro(
          info.entitlements.active['pro'] !== undefined
        );
      })
      .catch((error) => {
        // エラー時はデフォルトで非プロ扱い（deny by default）
        console.error('Failed to get customer info:', error);
        setIsPro(false);
      })
      .finally(() => {
        setIsLoading(false);
      });
 
    // 購入状態の変化をリアルタイムで受け取る
    const purchaserInfoUpdateListener = Purchases.addCustomerInfoUpdateListener(
      (info) => {
        setCustomerInfo(info);
        setIsPro(info.entitlements.active['pro'] !== undefined);
      }
    );
 
    return () => {
      purchaserInfoUpdateListener.remove();
    };
  }, []);
 
  return { isPro, isLoading, customerInfo };
}

// ログイン成功後に RevenueCat のユーザー ID を同期する
async function syncRevenueCatUserId(appUserId: string) {
  try {
    const { customerInfo, created } = await Purchases.logIn(appUserId);
    
    if (created) {
      // 新規ユーザー: Stripe Customer も新規作成が必要
      await createStripeCustomer(appUserId);
    }
    
    return customerInfo;
  } catch (error) {
    // ログイン失敗時も匿名ユーザーとして継続（購入はできないがアプリは動く）
    console.error('RevenueCat login failed:', error);
    return null;
  }
}
 
// Stripe Customer をバックエンド API 経由で作成
async function createStripeCustomer(appUserId: string) {
  const response = await fetch('/api/create-stripe-customer', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ appUserId }),
  });
  
  if (!response.ok) {
    throw new Error(`Failed to create Stripe customer: ${response.status}`);
  }
  
  return response.json();
}

// src/routes/stripe-webhook.ts
import { Hono } from 'hono';
import Stripe from 'stripe';
 
const app = new Hono();
 
app.post('/api/stripe-webhook', async (c) => {
  const stripe = new Stripe(c.env.STRIPE_SECRET_KEY);
  const signature = c.req.header('stripe-signature') ?? '';
  const rawBody = await c.req.text();
 
  // Stripe の署名検証（必須 - これを省略するとセキュリティホールになる）
  let event: Stripe.Event;
  try {
    event = await stripe.webhooks.constructEventAsync(
      rawBody,
      signature,
      c.env.STRIPE_WEBHOOK_SECRET,
      undefined,
      Stripe.createSubtleCryptoProvider()
    );
  } catch (err) {
    console.error('Webhook signature verification failed:', err);
    return c.json({ error: 'Invalid signature' }, 400);
  }
 
  // イベントタイプに応じた処理
  switch (event.type) {
    case 'checkout.session.completed':
      await handleCheckoutCompleted(event.data.object, c.env);
      break;
    case 'customer.subscription.updated':
      await handleSubscriptionUpdated(event.data.object, c.env);
      break;
    case 'customer.subscription.deleted':
      await handleSubscriptionDeleted(event.data.object, c.env);
      break;
    default:
      // 処理不要なイベントは無視（200 を返してリトライを防ぐ）
      break;
  }
 
  return c.json({ received: true }, 200);
});
 
async function handleCheckoutCompleted(
  session: Stripe.Checkout.Session,
  env: Env
) {
  const appUserId = session.metadata?.appUserId;
  if (!appUserId) {
    console.error('No appUserId in session metadata:', session.id);
    return;
  }
 
  // RevenueCat にカスタムエンタイトルメントを付与
  await grantRevenueCatEntitlement(
    appUserId,
    'pro',
    getExpirationDate(session),
    env
  );
 
  // Cloudflare KV にも保存（高速な権限確認のため）
  await env.KV.put(
    `subscription:${appUserId}`,
    JSON.stringify({
      status: 'active',
      source: 'stripe',
      stripeCustomerId: session.customer as string,
      expiresAt: getExpirationDate(session),
    }),
    { expirationTtl: 60 * 60 * 24 * 400 } // 400日間保持
  );
}
 
async function grantRevenueCatEntitlement(
  appUserId: string,
  entitlementId: string,
  expiresAt: string | null,
  env: Env
) {
  const url = `https://api.revenuecat.com/v1/subscribers/${appUserId}/entitlements/${entitlementId}/promotional`;
  
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${env.REVENUECAT_SECRET_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      duration: 'monthly', // または 'annual', 'lifetime'
      // expires_date は ISO 8601 形式で指定
      ...(expiresAt ? { expires_date: expiresAt } : {}),
    }),
  });
 
  if (!response.ok) {
    const errorBody = await response.text();
    throw new Error(
      `RevenueCat entitlement grant failed: ${response.status} - ${errorBody}`
    );
  }
 
  return response.json();
}
 
function getExpirationDate(session: Stripe.Checkout.Session): string | null {
  // サブスクリプションの場合は次回更新日を返す
  if (session.subscription) {
    // 実際には Stripe API でサブスクリプション詳細を取得して current_period_end を使う
    const thirtyDaysLater = new Date();
    thirtyDaysLater.setDate(thirtyDaysLater.getDate() + 30);
    return thirtyDaysLater.toISOString();
  }
  return null;
}

// src/routes/create-checkout.ts
app.post('/api/create-checkout', async (c) => {
  const { appUserId, priceId, successUrl, cancelUrl } = await c.req.json();
  
  if (!appUserId) {
    return c.json({ error: 'appUserId is required' }, 400);
  }
 
  const stripe = new Stripe(c.env.STRIPE_SECRET_KEY);
  
  // 既存の Stripe Customer を検索するか新規作成
  let stripeCustomerId = await getOrCreateStripeCustomer(appUserId, stripe, c.env);
 
  const session = await stripe.checkout.sessions.create({
    customer: stripeCustomerId,
    payment_method_types: ['card'],
    line_items: [{ price: priceId, quantity: 1 }],
    mode: 'subscription',
    success_url: successUrl,
    cancel_url: cancelUrl,
    metadata: {
      appUserId, // Webhook で RevenueCat と紐付けるための必須フィールド
    },
    subscription_data: {
      metadata: {
        appUserId, // サブスクリプションの metadata にも必ず設定する
      },
    },
  });
 
  return c.json({ url: session.url });
});
 
async function getOrCreateStripeCustomer(
  appUserId: string,
  stripe: Stripe,
  env: Env
): Promise<string> {
  // KV から既存の Stripe Customer ID を検索
  const existing = await env.KV.get(`stripe_customer:${appUserId}`);
  if (existing) {
    return existing;
  }
 
  // 新規作成
  const customer = await stripe.customers.create({
    metadata: { appUserId },
  });
 
  // KV に保存（次回以降の検索を高速化）
  await env.KV.put(`stripe_customer:${appUserId}`, customer.id);
  
  return customer.id;
}

async function handleSubscriptionUpdated(
  subscription: Stripe.Subscription,
  env: Env
) {
  const appUserId = subscription.metadata?.appUserId;
  if (!appUserId) {
    console.error('No appUserId in subscription metadata:', subscription.id);
    return;
  }
 
  const isActive = ['active', 'trialing'].includes(subscription.status);
  
  if (isActive) {
    // 更新成功: エンタイトルメントを延長
    const expiresAt = new Date(subscription.current_period_end * 1000).toISOString();
    await grantRevenueCatEntitlement(appUserId, 'pro', expiresAt, env);
    
    await env.KV.put(
      `subscription:${appUserId}`,
      JSON.stringify({
        status: 'active',
        source: 'stripe',
        expiresAt,
      }),
      { expirationTtl: 60 * 60 * 24 * 400 }
    );
  } else {
    // 支払い失敗・停止中: KV のみ更新し、RevenueCat は期限切れを待つ
    await env.KV.put(
      `subscription:${appUserId}`,
      JSON.stringify({
        status: subscription.status,
        source: 'stripe',
      })
    );
  }
}
 
async function handleSubscriptionDeleted(
  subscription: Stripe.Subscription,
  env: Env
) {
  const appUserId = subscription.metadata?.appUserId;
  if (!appUserId) return;
 
  // RevenueCat のプロモーショナルエンタイトルメントを取り消す
  const url = `https://api.revenuecat.com/v1/subscribers/${appUserId}/entitlements/pro/promotional`;
  await fetch(url, {
    method: 'DELETE',
    headers: {
      'Authorization': `Bearer ${env.REVENUECAT_SECRET_KEY}`,
    },
  });
 
  // KV から削除
  await env.KV.delete(`subscription:${appUserId}`);
}

// src/hooks/useProAccess.ts
export function useProAccess() {
  const [hasAccess, setHasAccess] = useState(false);
  const [isLoading, setIsLoading] = useState(true);
  const { user } = useAuth();
 
  useEffect(() => {
    if (!user) {
      setHasAccess(false);
      setIsLoading(false);
      return;
    }
 
    checkAccess(user.id);
  }, [user]);
 
  async function checkAccess(appUserId: string) {
    try {
      // まず RevenueCat SDK でローカルキャッシュを確認（高速）
      const customerInfo = await Purchases.getCustomerInfo();
      const revenueCatPro = customerInfo.entitlements.active['pro'] !== undefined;
 
      if (revenueCatPro) {
        setHasAccess(true);
        setIsLoading(false);
        return;
      }
 
      // RevenueCat でプロでない場合、バックエンドの KV も確認（Stripe 経由の可能性）
      const response = await fetch('/api/check-subscription', {
        headers: { 'x-app-user-id': appUserId },
      });
      const data = await response.json();
      
      setHasAccess(data.isActive === true);
    } catch (error) {
      // エラー時はデフォルトで非プロ（deny by default 原則を遵守）
      console.error('Access check failed:', error);
      setHasAccess(false);
    } finally {
      setIsLoading(false);
    }
  }
 
  return { hasAccess, isLoading };
}

// バックエンド側の /api/check-subscription エンドポイント
app.get('/api/check-subscription', async (c) => {
  const appUserId = c.req.header('x-app-user-id');
  if (!appUserId) {
    return c.json({ isActive: false }, 401);
  }
 
  const cached = await c.env.KV.get(`subscription:${appUserId}`);
  if (!cached) {
    return c.json({ isActive: false });
  }
 
  const data = JSON.parse(cached);
  const isActive = data.status === 'active' && 
    (!data.expiresAt || new Date(data.expiresAt) > new Date());
 
  return c.json({ isActive });
});

// 冪等性ガード: 同じ event.id は一度しか処理しない
async function alreadyProcessed(eventId: string, env: Env): Promise<boolean> {
  const key = `evt:${eventId}`;
  const seen = await env.KV.get(key);
  if (seen) return true;
 
  // 30日間記録する（Stripe のリトライ期間より十分長く取る）
  await env.KV.put(key, '1', { expirationTtl: 60 * 60 * 24 * 30 });
  return false;
}

// 署名検証の直後に挿入する
if (await alreadyProcessed(event.id, c.env)) {
  // すでに処理済み。200 を返してリトライを止める
  return c.json({ received: true, deduped: true }, 200);
}

// src/cron/reconcile.ts
// wrangler.toml に [triggers] crons = ["0 18 * * *"] を設定（JST 03:00 相当）
export async function reconcileSubscriptions(env: Env) {
  const stripe = new Stripe(env.STRIPE_SECRET_KEY);
  let processed = 0;
  let repaired = 0;
 
  // アクティブなサブスクリプションを Stripe から取得して KV と照合する
  for await (const sub of stripe.subscriptions.list({
    status: 'active',
    limit: 100,
    expand: ['data.customer'],
  })) {
    const appUserId = sub.metadata?.appUserId;
    if (!appUserId) continue;
    processed++;
 
    const expiresAt = new Date(sub.current_period_end * 1000).toISOString();
    const cached = await env.KV.get(`subscription:${appUserId}`);
    const parsed = cached ? JSON.parse(cached) : null;
 
    // KV が無い・状態や期限がずれている場合は Stripe を正として修復する
    const drift = !parsed || parsed.status !== 'active' || parsed.expiresAt !== expiresAt;
    if (drift) {
      await grantRevenueCatEntitlement(appUserId, 'pro', expiresAt, env);
      await env.KV.put(
        `subscription:${appUserId}`,
        JSON.stringify({ status: 'active', source: 'stripe', expiresAt }),
        { expirationTtl: 60 * 60 * 24 * 400 }
      );
      repaired++;
    }
  }
 
  console.log(`reconcile done: processed=${processed} repaired=${repaired}`);
}

async function handleSubscriptionUpdated(
  subscription: Stripe.Subscription,
  env: Env
) {
  const appUserId = subscription.metadata?.appUserId;
  if (!appUserId) return;
 
  const status = subscription.status;
  // active / trialing に加えて past_due も「猶予中」として権限を維持する
  const inGrace = status === 'past_due';
  const isEntitled = ['active', 'trialing'].includes(status) || inGrace;
 
  if (isEntitled) {
    // 現在の請求期間末を期限として権限を延長する
    const expiresAt = new Date(subscription.current_period_end * 1000).toISOString();
    await grantRevenueCatEntitlement(appUserId, 'pro', expiresAt, env);
    await env.KV.put(
      `subscription:${appUserId}`,
      JSON.stringify({ status, source: 'stripe', expiresAt, grace: inGrace }),
      { expirationTtl: 60 * 60 * 24 * 400 }
    );
  } else {
    // canceled / unpaid など: 即時剥奪せず、期限切れに任せる
    await env.KV.put(
      `subscription:${appUserId}`,
      JSON.stringify({ status, source: 'stripe' })
    );
  }
}