Claude Code と作る StoreKit 2 × SwiftUI の課金実装 — 審査を通る最小構成と運用の落とし穴

import StoreKit
import Observation
 
@Observable
final class PurchaseManager {
    // MARK: - 購入可能な商品一覧
    private(set) var products: [Product] = []
 
    // MARK: - サブスクリプション状態
    private(set) var isSubscribed: Bool = false
 
    // MARK: - 購入済み消耗型アイテムのID群
    private(set) var purchasedConsumables: Set<String> = []
 
    // MARK: - エラー状態
    private(set) var purchaseError: String?
 
    // MARK: - ローディング状態
    private(set) var isPurchasing: Bool = false
 
    // MARK: - Product ID 定義
    private let productIDs: Set<String> = [
        "com.yourcompany.appname.premium_filter",
        "com.yourcompany.appname.pro_monthly",
        "com.yourcompany.appname.pro_yearly"
    ]
 
    // Transaction監視タスク
    private var updateListenerTask: Task<Void, Error>?
 
    init() {
        // アプリ起動時にTransactionリスナーを開始
        updateListenerTask = listenForTransactions()
 
        Task {
            await loadProducts()
            await updateSubscriptionStatus()
        }
    }
 
    deinit {
        updateListenerTask?.cancel()
    }
 
    // MARK: - 商品一覧の取得
    @MainActor
    func loadProducts() async {
        do {
            // App Store Connectから商品情報を取得
            let fetchedProducts = try await Product.products(for: productIDs)
            // 価格順にソート
            products = fetchedProducts.sorted { $0.price < $1.price }
        } catch {
            // 商品取得失敗（ネットワーク障害などで発生）
            purchaseError = "商品情報の取得に失敗しました: \(error.localizedDescription)"
        }
    }
 
    // MARK: - 購入処理
    @MainActor
    func purchase(_ product: Product) async {
        isPurchasing = true
        purchaseError = nil
 
        do {
            // 購入リクエスト
            let result = try await product.purchase()
 
            switch result {
            case .success(let verificationResult):
                // レシートの検証
                let transaction = try checkVerified(verificationResult)
 
                // サブスクリプション状態の更新
                await updateSubscriptionStatus()
 
                // 消耗型アイテムの場合は購入完了を記録
                if product.type == .consumable {
                    purchasedConsumables.insert(product.id)
                    // 消耗型はfinishを忘れずに呼ぶ
                    await transaction.finish()
                } else {
                    await transaction.finish()
                }
 
            case .userCancelled:
                // ユーザーが購入をキャンセル（エラーではない）
                break
 
            case .pending:
                // 保護者の承認待ち（Ask to Buy）などの状態
                purchaseError = "購入の承認を待っています。保護者の方に確認してください。"
 
            @unknown default:
                purchaseError = "予期しない購入結果です。もう一度お試しください。"
            }
        } catch StoreKitError.userCancelled {
            // ユーザーキャンセルは正常なフロー
            break
        } catch StoreKitError.notAvailableInStorefront {
            purchaseError = "この商品は現在の地域では購入できません。"
        } catch StoreKitError.networkError(let urlError) {
            purchaseError = "ネットワークエラー: \(urlError.localizedDescription)"
        } catch {
            purchaseError = "購入処理に失敗しました: \(error.localizedDescription)"
        }
 
        isPurchasing = false
    }
 
    // MARK: - レシート検証
    private func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .unverified(_, let verificationError):
            // Appleの署名検証に失敗した場合（改ざんの可能性）
            throw verificationError
        case .verified(let signedType):
            return signedType
        }
    }
 
    // MARK: - サブスクリプション状態の更新
    @MainActor
    func updateSubscriptionStatus() async {
        var hasActiveSubscription = false
 
        // 現在有効な全Transactionを確認
        for await result in Transaction.currentEntitlements {
            do {
                let transaction = try checkVerified(result)
 
                // サブスクリプション商品かつ有効期限内であることを確認
                if transaction.productType == .autoRenewable
                    && transaction.revocationDate == nil {
                    hasActiveSubscription = true
                }
            } catch {
                // 検証エラーのTransactionはスキップ
                continue
            }
        }
 
        isSubscribed = hasActiveSubscription
    }
 
    // MARK: - Transaction更新のリスナー
    private func listenForTransactions() -> Task<Void, Error> {
        return Task.detached {
            // App外での購入（サブスクリプション更新など）を監視
            for await result in Transaction.updates {
                do {
                    let transaction = try self.checkVerified(result)
                    await self.updateSubscriptionStatus()
                    await transaction.finish()
                } catch {
                    // 検証エラーのTransactionはfinishしない
                    print("Transaction verification failed: \(error)")
                }
            }
        }
    }
 
    // MARK: - 購入の復元
    @MainActor
    func restorePurchases() async {
        isPurchasing = true
        do {
            // App Store に購入履歴の同期を要求
            try await AppStore.sync()
            await updateSubscriptionStatus()
        } catch {
            purchaseError = "購入の復元に失敗しました: \(error.localizedDescription)"
        }
        isPurchasing = false
    }
}

enum SubscriptionStatus: Equatable {
    case notSubscribed           // 未購読
    case inTrial(expiresDate: Date)  // 試用期間中
    case active(plan: SubscriptionPlan, expiresDate: Date)  // 有効
    case gracePeriod(expiresDate: Date)  // 支払い猶予期間
    case billingRetry            // 支払い再試行中
    case expired                 // 期限切れ
    case revoked                 // 払い戻し済み
 
    var isEntitled: Bool {
        switch self {
        case .inTrial, .active, .gracePeriod:
            return true
        default:
            return false
        }
    }
}
 
enum SubscriptionPlan: String {
    case monthly = "com.yourcompany.appname.pro_monthly"
    case yearly = "com.yourcompany.appname.pro_yearly"
}

// MARK: - 詳細なサブスクリプション状態の取得
@MainActor
func fetchSubscriptionStatus() async -> SubscriptionStatus {
    let subscriptionIDs: [String] = [
        SubscriptionPlan.monthly.rawValue,
        SubscriptionPlan.yearly.rawValue
    ]
 
    // サブスクリプション商品の最新ステータスを取得
    guard let product = products.first(where: { subscriptionIDs.contains($0.id) }),
          let statuses = try? await product.subscription?.status else {
        return .notSubscribed
    }
 
    // 最も優先度の高いステータスを返す
    for status in statuses {
        guard let renewalInfo = try? status.renewalInfo.payloadValue,
              let transaction = try? status.transaction.payloadValue else {
            continue
        }
 
        switch status.state {
        case .subscribed:
            let plan = SubscriptionPlan(rawValue: transaction.productID) ?? .monthly
            let expiresDate = transaction.expirationDate ?? Date()
            // 試用期間中かどうかを確認
            if transaction.offerType == .introductoryOffer {
                return .inTrial(expiresDate: expiresDate)
            }
            return .active(plan: plan, expiresDate: expiresDate)
 
        case .inGracePeriod:
            return .gracePeriod(expiresDate: transaction.expirationDate ?? Date())
 
        case .inBillingRetryPeriod:
            return .billingRetry
 
        case .revoked:
            return .revoked
 
        case .expired:
            // 解約済みだが有効期限内のケースを確認
            if let expiresDate = transaction.expirationDate, expiresDate > Date() {
                let plan = SubscriptionPlan(rawValue: transaction.productID) ?? .monthly
                return .active(plan: plan, expiresDate: expiresDate)
            }
            return .expired
 
        @unknown default:
            continue
        }
    }
 
    return .notSubscribed
}

// ❌ サーバーの環境変数と、トランザクションの発生した環境は別物
const baseUrl = process.env.NODE_ENV === 'production'
  ? 'https://api.storekit.itunes.apple.com'
  : 'https://api.storekit-sandbox.itunes.apple.com';

import { SignJWT, importPKCS8 } from 'jose';
import { SignedDataVerifier, Environment } from '@apple/app-store-server-library';
 
const PRODUCTION_URL = 'https://api.storekit.itunes.apple.com';
const SANDBOX_URL = 'https://api.storekit-sandbox.itunes.apple.com';
 
class AppStoreServerAPI {
  private readonly bundleId: string;
  private readonly issuerId: string;
  private readonly keyId: string;
  private readonly privateKey: string;
  private readonly appAppleId: number;
  // Apple Root CA G3 等のルート証明書（DER）を読み込んで渡す
  private readonly rootCerts: Buffer[];
 
  constructor(config: {
    bundleId: string;
    issuerId: string;
    keyId: string;
    privateKey: string; // YOUR_PRIVATE_KEY（.p8 の中身）
    appAppleId: number;
    rootCerts: Buffer[];
  }) {
    this.bundleId = config.bundleId;
    this.issuerId = config.issuerId;
    this.keyId = config.keyId;
    this.privateKey = config.privateKey;
    this.appAppleId = config.appAppleId;
    this.rootCerts = config.rootCerts;
  }
 
  // JWT トークンの生成（有効期限は最大60分）
  private async generateToken(): Promise<string> {
    const privateKey = await importPKCS8(this.privateKey, 'ES256');
 
    return new SignJWT({ bid: this.bundleId })
      .setProtectedHeader({ alg: 'ES256', kid: this.keyId, typ: 'JWT' })
      .setIssuer(this.issuerId)
      .setIssuedAt()
      .setAudience('appstoreconnect-v1')
      .setExpirationTime('20m') // 使い回す場合は失効の余裕を持たせる
      .sign(privateKey);
  }
 
  private async request(path: string, baseUrl: string): Promise<Response> {
    const token = await this.generateToken();
    return fetch(`${baseUrl}${path}`, {
      headers: { Authorization: `Bearer ${token}` },
    });
  }
 
  // 本番 → サンドボックスの順に問い合わせ、成功した側の環境も返す
  private async requestWithEnvironmentFallback(
    path: string
  ): Promise<{ body: unknown; environment: Environment }> {
    const production = await this.request(path, PRODUCTION_URL);
    if (production.ok) {
      return { body: await production.json(), environment: Environment.PRODUCTION };
    }
 
    if (production.status === 404) {
      const { errorCode } = (await production.json().catch(() => ({}))) as {
        errorCode?: number;
      };
      // 4040010 = TransactionIdNotFoundError。サンドボックス側を確認する
      if (errorCode === 4040010) {
        const sandbox = await this.request(path, SANDBOX_URL);
        if (sandbox.ok) {
          return { body: await sandbox.json(), environment: Environment.SANDBOX };
        }
        throw new Error(`transactionId not found in either environment: ${path}`);
      }
    }
 
    throw new Error(`App Store Server API error: ${production.status}`);
  }
 
  // トランザクション情報を取得し、JWS の署名を検証してから返す
  async getVerifiedTransaction(transactionId: string) {
    const { body, environment } = await this.requestWithEnvironmentFallback(
      `/inApps/v1/transactions/${transactionId}`
    );
 
    const { signedTransactionInfo } = body as { signedTransactionInfo: string };
 
    // 証明書チェーンの検証を含む。ここを省略すると検証したことにならない
    const verifier = new SignedDataVerifier(
      this.rootCerts,
      true, // オンラインでの証明書失効確認を有効にする
      environment,
      this.bundleId,
      this.appAppleId
    );
 
    return verifier.verifyAndDecodeTransaction(signedTransactionInfo);
  }
 
  // サブスクリプション状態の取得（全デバイス共通）
  async getSubscriptionStatuses(transactionId: string) {
    const { body } = await this.requestWithEnvironmentFallback(
      `/inApps/v1/subscriptions/${transactionId}`
    );
    return body;
  }
}
 
export { AppStoreServerAPI };

struct PaywallView: View {
    @Environment(PurchaseManager.self) private var purchaseManager
    @State private var selectedPlan: Product?
    @State private var showError: Bool = false
    @Environment(\.dismiss) private var dismiss
 
    var body: some View {
        NavigationStack {
            ScrollView {
                VStack(spacing: 24) {
                    // ヘッダー: プレミアム機能の魅力訴求
                    paywallHeader
 
                    // 機能一覧
                    featureList
 
                    // プラン選択
                    planSelector
 
                    // 購入ボタン
                    purchaseButton
 
                    // 復元リンク
                    restoreButton
 
                    // 利用規約・プライバシーポリシー
                    legalLinks
                }
                .padding()
            }
            .navigationTitle("Pro にアップグレード")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .navigationBarLeading) {
                    Button("閉じる") { dismiss() }
                }
            }
            .alert("エラー", isPresented: $showError) {
                Button("OK") { purchaseManager.purchaseError = nil }
            } message: {
                Text(purchaseManager.purchaseError ?? "")
            }
            .onChange(of: purchaseManager.purchaseError) { _, error in
                showError = error != nil
            }
            .task {
                // ビュー表示時に最新の商品情報を取得
                await purchaseManager.loadProducts()
                // デフォルトで年額プランを選択（割引感を強調）
                selectedPlan = purchaseManager.products.first {
                    $0.id == SubscriptionPlan.yearly.rawValue
                }
            }
        }
    }
 
    // MARK: - ヘッダー
    private var paywallHeader: some View {
        VStack(spacing: 12) {
            Image(systemName: "star.fill")
                .font(.system(size: 64))
                .foregroundStyle(.yellow)
 
            Text("Pro で写真編集を解放しよう")
                .font(.title2.bold())
                .multilineTextAlignment(.center)
 
            Text("プロフェッショナルなフィルター・高度な編集ツール・広告なし体験")
                .font(.body)
                .foregroundStyle(.secondary)
                .multilineTextAlignment(.center)
        }
    }
 
    // MARK: - プラン選択UI
    private var planSelector: some View {
        VStack(spacing: 12) {
            ForEach(purchaseManager.products.filter {
                $0.type == .autoRenewable
            }) { product in
                PlanCard(
                    product: product,
                    isSelected: selectedPlan?.id == product.id,
                    isYearly: product.id == SubscriptionPlan.yearly.rawValue
                )
                .onTapGesture {
                    withAnimation(.easeInOut(duration: 0.2)) {
                        selectedPlan = product
                    }
                }
            }
        }
    }
 
    // MARK: - 購入ボタン
    private var purchaseButton: some View {
        Button {
            guard let plan = selectedPlan else { return }
            Task {
                await purchaseManager.purchase(plan)
                if purchaseManager.isSubscribed {
                    dismiss()
                }
            }
        } label: {
            Group {
                if purchaseManager.isPurchasing {
                    ProgressView()
                        .tint(.white)
                } else {
                    Text(selectedPlan.map {
                        "始める — \($0.displayPrice)"
                    } ?? "プランを選択してください")
                    .fontWeight(.semibold)
                }
            }
            .frame(maxWidth: .infinity)
            .frame(height: 56)
        }
        .buttonStyle(.borderedProminent)
        .disabled(selectedPlan == nil || purchaseManager.isPurchasing)
    }
 
    // MARK: - 購入復元
    private var restoreButton: some View {
        Button("以前の購入を復元する") {
            Task {
                await purchaseManager.restorePurchases()
                if purchaseManager.isSubscribed {
                    dismiss()
                }
            }
        }
        .font(.footnote)
        .foregroundStyle(.secondary)
    }
 
    // MARK: - 法的リンク
    private var legalLinks: some View {
        HStack(spacing: 8) {
            Link("利用規約", destination: URL(string: "https://yourapp.com/terms")!)
            Text("・")
            Link("プライバシーポリシー", destination: URL(string: "https://yourapp.com/privacy")!)
        }
        .font(.caption)
        .foregroundStyle(.secondary)
    }
}
 
// MARK: - プランカードコンポーネント
struct PlanCard: View {
    let product: Product
    let isSelected: Bool
    let isYearly: Bool
 
    var body: some View {
        HStack {
            VStack(alignment: .leading, spacing: 4) {
                HStack {
                    Text(isYearly ? "年額プラン" : "月額プラン")
                        .font(.headline)
                    if isYearly {
                        // 年額の割引バッジ
                        Text("2ヶ月分お得")
                            .font(.caption.bold())
                            .padding(.horizontal, 8)
                            .padding(.vertical, 2)
                            .background(.green)
                            .foregroundColor(.white)
                            .clipShape(.capsule)
                    }
                }
 
                if isYearly {
                    // 月換算額を表示（購買意欲向上）
                    Text("月あたり約\(monthlyEquivalent)/月換算")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                } else {
                    product.subscription?.introductoryOffer.map { _ in
                        Text("7日間無料トライアル付き")
                            .font(.caption)
                            .foregroundStyle(.green)
                    }
                }
            }
 
            Spacer()
 
            VStack(alignment: .trailing) {
                Text(product.displayPrice)
                    .font(.title3.bold())
                Text(isYearly ? "/ 年" : "/ 月")
                    .font(.caption)
                    .foregroundStyle(.secondary)
            }
        }
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 12)
                .fill(isSelected ? Color.accentColor.opacity(0.1) : Color(.systemGray6))
                .stroke(isSelected ? Color.accentColor : Color.clear, lineWidth: 2)
        )
    }
 
    // 年額から月換算を計算
    private var monthlyEquivalent: String {
        guard let decimal = product.price as Decimal?,
              decimal > 0 else { return "" }
        let monthly = decimal / 12
        // ロケールに合わせたフォーマット
        return product.priceFormatStyle.format(monthly)
    }
}

import XCTest
import StoreKit
@testable import YourApp
 
final class PurchaseManagerTests: XCTestCase {
    var purchaseManager: PurchaseManager!
 
    override func setUp() async throws {
        purchaseManager = PurchaseManager()
        // StoreKit Testing の設定ファイルを読み込む
        try await SKTestSession.shared.clearTransactions()
    }
 
    // 商品読み込みのテスト
    func testLoadProductsReturnsProducts() async throws {
        await purchaseManager.loadProducts()
        XCTAssertFalse(purchaseManager.products.isEmpty, "商品リストが空です")
        XCTAssertEqual(purchaseManager.products.count, 3, "3商品が読み込まれるはず")
    }
 
    // 購入成功のテスト
    func testPurchaseMonthlySubscriptionSucceeds() async throws {
        await purchaseManager.loadProducts()
 
        guard let monthlyProduct = purchaseManager.products.first(where: {
            $0.id == "com.yourcompany.appname.pro_monthly"
        }) else {
            XCTFail("月額商品が見つかりません")
            return
        }
 
        // テスト環境での購入実行
        await purchaseManager.purchase(monthlyProduct)
        XCTAssertNil(purchaseManager.purchaseError, "エラーが発生しました: \(purchaseManager.purchaseError ?? "")")
        XCTAssertTrue(purchaseManager.isSubscribed, "購入後に isSubscribed が true になるはず")
    }
}

// ❌ 間違い: ViewModelやViewで遅れてリスナーを開始する
struct ContentView: View {
    var body: some View {
        Text("Hello")
            .task {
                // このタイミングでは App 起動直後のトランザクションを取り逃す
                for await result in Transaction.updates { ... }
            }
    }
}
 
// ✅ 正しい: App初期化時に必ず開始する
@main
struct YourApp: App {
    @State private var purchaseManager = PurchaseManager() // init内でリスナーを開始
 
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(purchaseManager)
        }
    }
}

// ❌ 間違い: finish()を呼ばないと次回購入が「待機中」になる
case .success(let result):
    let transaction = try checkVerified(result)
    grantConsumableItem() // アイテムを付与
    // finish() がない！→ 次回購入時に同じTransactionが再処理される
 
// ✅ 正しい: アイテム付与後に必ずfinish()
case .success(let result):
    let transaction = try checkVerified(result)
    grantConsumableItem()
    await transaction.finish() // 必須

// ❌ 間違い: 全Transactionを有効なサブスクリプションとして処理
for await result in Transaction.currentEntitlements {
    isSubscribed = true // 一度購入した消耗型も含まれてしまう
}
 
// ✅ 正しい: productTypeとrevocationDateを確認
for await result in Transaction.currentEntitlements {
    let transaction = try checkVerified(result)
    if transaction.productType == .autoRenewable
        && transaction.revocationDate == nil {
        isSubscribed = true
    }
}

@MainActor
final class PurchaseManager: ObservableObject {
    @Published private(set) var isInitialFetchComplete = false
    @Published private(set) var purchasedProductIDs: Set<String> = []
 
    private let cacheKey = "cached_purchased_product_ids"
 
    init() {
        // 1. キャッシュから即座に復元
        if let cached = UserDefaults.standard.array(forKey: cacheKey) as? [String] {
            purchasedProductIDs = Set(cached)
        }
        // 2. バックグラウンドで Transaction.updates を購読
        Task { await observeTransactions() }
    }
 
    private func observeTransactions() async {
        // 起動時に既存のエンタイトルメントを同期
        await syncEntitlements()
        isInitialFetchComplete = true
 
        // 以後の更新を継続的に監視
        for await update in Transaction.updates {
            await handleTransaction(update)
        }
    }
 
    private func syncEntitlements() async {
        var ids: Set<String> = []
        for await result in Transaction.currentEntitlements {
            if case .verified(let tx) = result {
                ids.insert(tx.productID)
            }
        }
        purchasedProductIDs = ids
        UserDefaults.standard.set(Array(ids), forKey: cacheKey)
    }
}

enum PurchasePhase: Equatable {
    case idle
    case purchasing
    case awaitingApproval   // Ask to Buy の承認待ち
    case completed
    case failed(String)
}
 
@MainActor
func purchase(_ product: Product) async {
    phase = .purchasing
    do {
        let result = try await product.purchase()
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await updatePurchasedProducts()
            await transaction.finish()
            phase = .completed
        case .pending:
            // 承認待ち。ここでは finish() できるトランザクションが存在しない
            phase = .awaitingApproval
        case .userCancelled:
            phase = .idle
        @unknown default:
            phase = .idle
        }
    } catch {
        phase = .failed(error.localizedDescription)
    }
}

let result = try await product.purchase(options: [
    .appAccountToken(userUUID)  // 自社サーバーで発行した安定 ID
])