In-App Purchases and Subscriptions with StoreKit 2

// Packages/FieldNotesKit/Sources/FieldNotesServices/Store/StoreManager.swift
import Foundation
import Observation
import StoreKit

@Observable @MainActor
public final class StoreManager {
    public static let productIDs: [Product.ID] = [
        "com.example.fieldnotes.pro.monthly",
        "com.example.fieldnotes.pro.yearly",
    ]
    /// The "FieldNotes Pro" group ID from App Store Connect (and from Products.storekit).
    public static let proGroupID = "21500001"

    public private(set) var products: [Product] = []
    public private(set) var isPro = false
    public private(set) var proRenewalState: Product.SubscriptionInfo.RenewalState?

    @ObservationIgnored private var updatesTask: Task<Void, Never>?

    public init() {
        // Start listening before anything else, so no transaction is missed.
        updatesTask = Task { [weak self] in
            for await result in Transaction.updates {
                await self?.handle(result)
            }
        }
    }

    public func loadProducts() async {
        do {
            products = try await Product.products(for: Self.productIDs)
                .sorted { $0.price < $1.price }
        } catch {
            products = []          // offline or misconfigured: the store UI shows a retry button
        }
    }
}

// FieldNotes/FieldNotesApp.swift (excerpt)
import FieldNotesServices
import SwiftUI

@main
struct FieldNotesApp: App {
    @State private var store = AppServices.shared.store   // the single owner, see Background Execution
    @State private var storeManager = StoreManager()   // Transaction.updates starts here

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(store)
                .environment(storeManager)
                .task {
                    await storeManager.loadProducts()
                    await storeManager.refreshEntitlements()
                }
        }
    }
}

// StoreManager.swift (continued)
extension StoreManager {
    public enum PurchaseOutcome { case unlocked, pending, cancelled }

    public func purchase(_ product: Product, using purchaseAction: PurchaseAction,
                         accountID: UUID? = nil) async throws -> PurchaseOutcome {
        var options: Set<Product.PurchaseOption> = []
        if let accountID { options.insert(.appAccountToken(accountID)) }   // ties it to the FieldNotes account

        switch try await purchaseAction(product, options: options) {
        case .success(let verification):
            await handle(verification)
            return isPro ? .unlocked : .pending
        case .pending:
            return .pending          // Ask to Buy or Strong Customer Authentication; arrives via updates
        case .userCancelled:
            return .cancelled
        @unknown default:
            return .cancelled
        }
    }
}

// FieldNotes/Views/ProUpgradeButton.swift
struct ProUpgradeButton: View {
    @Environment(StoreManager.self) private var storeManager
    @Environment(\.purchase) private var purchase
    let product: Product

    var body: some View {
        Button("Subscribe for \(product.displayPrice)") {
            Task { _ = try? await storeManager.purchase(product, using: purchase) }
        }
    }
}

// StoreManager.swift (continued)
extension StoreManager {
    func handle(_ result: VerificationResult<Transaction>) async {
        switch result {
        case .verified(let transaction):
            await refreshEntitlements()
            await transaction.finish()            // tell the App Store the content was delivered
        case .unverified(let transaction, let error):
            // Signed by someone else, or for another device: never unlock anything.
            print("Unverified transaction \(transaction.id): \(error)")
        }
    }
}

// StoreManager.swift (continued)
extension StoreManager {
    public func refreshEntitlements() async {
        var entitled = false
        for await result in Transaction.currentEntitlements {
            guard case .verified(let transaction) = result,
                  Self.productIDs.contains(transaction.productID),
                  transaction.revocationDate == nil,              // not refunded
                  !transaction.isUpgraded else { continue }      // superseded by another product
            if let expiry = transaction.expirationDate, expiry < .now { continue }
            entitled = true
        }
        isPro = entitled
    }
}

// StoreManager.swift (continued)
extension StoreManager {
    public func refreshStatus() async {
        let statuses = (try? await Product.SubscriptionInfo.status(for: Self.proGroupID)) ?? []
        proRenewalState = statuses
            .filter { if case .verified = $0.transaction { true } else { false } }
            .map(\.state)
            .first
    }
}

// In a view, the modifier form keeps the status current without a manual refresh:
// .subscriptionStatusTask(for: StoreManager.proGroupID) { taskState in
//     if case .success(let statuses) = taskState,
//        statuses.contains(where: { $0.state == .inGracePeriod }) { showPaymentBanner = true }
// }

// FieldNotes/Views/SettingsView+Store.swift (excerpt)
Button("Restore Purchases") {
    Task {
        try? await AppStore.sync()
        await storeManager.refreshEntitlements()
    }
}

// StoreManager.swift (continued)
extension StoreManager {
    /// The yearly product's monthly commitment plan, if this storefront offers it.
    @available(iOS 26.4, macOS 26.4, watchOS 26.4, visionOS 26.4, *)
    public func commitmentTerms(for product: Product) -> Product.SubscriptionInfo.PricingTerms? {
        product.subscription?.pricingTerms.first { $0.billingPlanType == .monthly }
    }

    @available(iOS 26.4, macOS 26.4, watchOS 26.4, visionOS 26.4, *)
    public func purchaseCommitment(_ product: Product, using purchaseAction: PurchaseAction) async throws {
        let result = try await purchaseAction(product, options: [.billingPlanType(.monthly)])
        if case .success(let verification) = result { await handle(verification) }
    }
}

// FieldNotes/Views/CommitmentOfferRow.swift
struct CommitmentOfferRow: View {
    @Environment(StoreManager.self) private var storeManager
    @Environment(\.purchase) private var purchase
    let yearly: Product

    var body: some View {
        if #available(iOS 26.4, macOS 26.4, watchOS 26.4, visionOS 26.4, *),
           let terms = storeManager.commitmentTerms(for: yearly) {
            VStack(alignment: .leading) {
                // Both amounts must be visible before the person subscribes.
                Text("\(terms.billingDisplayPrice) per month for 12 months")
                Text("Total commitment: \(terms.commitmentInfo.displayPrice)")
                    .font(.footnote).foregroundStyle(.secondary)
                Button("Pay Monthly") {
                    Task { try? await storeManager.purchaseCommitment(yearly, using: purchase) }
                }
            }
        }
    }
}

SubscriptionStoreView(groupID: StoreManager.proGroupID)
    .preferredSubscriptionPricingTerms { _, subscriptionInfo in
        subscriptionInfo.pricingTerms.first { $0.billingPlanType == .monthly }
    }

@available(iOS 26.4, macOS 26.4, watchOS 26.4, visionOS 26.4, *)
func commitmentProgress(of transaction: Transaction) -> String? {
    guard transaction.billingPlanType == .monthly, let info = transaction.commitmentInfo else { return nil }
    return "Payment \(info.billingPeriodNumber) of \(info.totalBillingPeriods)"
}

struct RedeemCodeButton: View {
    @Environment(StoreManager.self) private var storeManager
    @State private var isPresented = false

    var body: some View {
        Button("Redeem Code") { isPresented = true }
        #if !os(watchOS)
            .modifier(RedeemSheet(isPresented: $isPresented, storeManager: storeManager))
        #endif
    }
}

#if !os(watchOS)
private struct RedeemSheet: ViewModifier {
    @Binding var isPresented: Bool
    let storeManager: StoreManager

    func body(content: Content) -> some View {
        if #available(iOS 27, macOS 27, visionOS 27, *) {
            content.offerCodeRedemption(options: [], isPresented: $isPresented) { result in
                if case .success(let verification) = result {
                    Task { await storeManager.handle(verification) }
                }
            }
        } else {
            content.offerCodeRedemption(isPresented: $isPresented)   // 26: the result arrives via updates
        }
    }
}
#endif

{
  "subscriptionGroups" : [
    {
      "id" : "21500001",
      "name" : "FieldNotes Pro",
      "subscriptions" : [
        {
          "productID" : "com.example.fieldnotes.pro.monthly",
          "displayPrice" : "3.99",
          "recurringSubscriptionPeriod" : "P1M",
          "groupNumber" : 2,
          "type" : "RecurringSubscription",
          "localizations" : [ { "locale" : "en_US", "displayName" : "FieldNotes Pro Monthly",
                                "description" : "All Pro features, billed monthly" } ]
        },
        {
          "productID" : "com.example.fieldnotes.pro.yearly",
          "displayPrice" : "34.99",
          "recurringSubscriptionPeriod" : "P1Y",
          "groupNumber" : 1,
          "type" : "RecurringSubscription",
          "localizations" : [ { "locale" : "en_US", "displayName" : "FieldNotes Pro Yearly",
                                "description" : "All Pro features, billed yearly" } ]
        }
      ]
    }
  ]
}

// FieldNotesKitTests/StoreManagerTests.swift
import FieldNotesServices
import StoreKit
import StoreKitTest
import Testing

@MainActor
struct StoreManagerTests {
    @Test func buyingYearlyUnlocksPro() async throws {
        let session = try SKTestSession(configurationFileNamed: "Products")
        session.disableDialogs = true
        session.clearTransactions()

        let manager = StoreManager()
        _ = try await session.buyProduct(identifier: "com.example.fieldnotes.pro.yearly", options: [])
        await manager.refreshEntitlements()
        #expect(manager.isPro)

        try session.expireSubscription(productIdentifier: "com.example.fieldnotes.pro.yearly")
        await manager.refreshEntitlements()
        #expect(!manager.isPro)
    }
}