05 · The flag that was never off

public enum LegacyFlagKey: String, CaseIterable, Sendable {
    case newCardBanner = "new_card_banner"
    case instantTransfers = "instant_transfers"
    case spendingInsights = "spending_insights"
}

/// The flag SDK the app shipped with: synchronous, backed by UserDefaults.
public final class LegacyFlags: @unchecked Sendable {   // UserDefaults is thread-safe, and `defaults` never changes
    public static let shared = LegacyFlags()

    private let defaults: UserDefaults
    // ... unchanged ...

    public func isEnabled(_ key: LegacyFlagKey) -> Bool {
        print("[LegacyFlags] read \(key.rawValue)")
        // Fail closed: a flag we can't find is a feature that isn't ready.
        return defaults.object(forKey: key.rawValue) as? Bool ?? false
    }

// Wallet/Wallet/HomeFlags.swift
import FlagsKit

/// What the home screen needs to know, read once, as plain values.
struct HomeFlags: Equatable {
    var showsCardBanner = false
    var allowsInstantTransfer = false
    var showsSpendingInsights = false
}

protocol HomeFlagsProviding {
    func homeFlags() -> HomeFlags
}

/// The only place in the app that knows about the legacy SDK.
struct LegacyHomeFlags: HomeFlagsProviding {
    let flags: LegacyFlags

    func homeFlags() -> HomeFlags {
        HomeFlags(
            showsCardBanner: flags.isEnabled(.newCardBanner),
            allowsInstantTransfer: flags.isEnabled(.instantTransfers),
            showsSpendingInsights: flags.isEnabled(.spendingInsights)
        )
    }
}

import Foundation
import Observation

@Observable
final class HomeViewModel {   // main actor: the target's default isolation
    var balance: Decimal = 1240.50
    var isBalanceHidden = false
    private(set) var flags: HomeFlags

    init(flags provider: any HomeFlagsProviding) {
        flags = provider.homeFlags()   // once per screen, not once per render
    }

    var showsCardBanner: Bool { flags.showsCardBanner }
    var showsInstantTransfer: Bool { flags.allowsInstantTransfer && balance > 0 }
    var showsSpendingInsights: Bool { flags.showsSpendingInsights }
}

struct RootView: View {
    @State private var selectedTab = AppTab.home
    @State private var home: HomeViewModel     // owned here, so it outlives a tab switch

    init(flags: any HomeFlagsProviding = LegacyHomeFlags(flags: .shared)) {
        _home = State(initialValue: HomeViewModel(flags: flags))
    }

    var body: some View {
        TabView(selection: $selectedTab) {
            Tab("Home", systemImage: "house", value: AppTab.home) {
                NavigationStack {
                    HomeView(viewModel: home)
                }
            }
        // ... the Settings tab, unchanged ...

import Testing
@testable import Wallet

private struct FakeFlags: HomeFlagsProviding {
    var flags: HomeFlags
    func homeFlags() -> HomeFlags { flags }
}

struct HomeViewModelTests {

    @Test func showsInstantTransferWithAPositiveBalance() {
        let viewModel = HomeViewModel(flags: FakeFlags(flags: HomeFlags(allowsInstantTransfer: true)))
        #expect(viewModel.showsInstantTransfer)
    }

    @Test func hidesInstantTransferWhenTheFlagIsOff() {
        let viewModel = HomeViewModel(flags: FakeFlags(flags: HomeFlags(allowsInstantTransfer: false)))
        #expect(!viewModel.showsInstantTransfer)
    }

    @Test func hidesInstantTransferWithAnEmptyBalance() {
        let viewModel = HomeViewModel(flags: FakeFlags(flags: HomeFlags(allowsInstantTransfer: true)))
        viewModel.balance = 0
        #expect(!viewModel.showsInstantTransfer)
    }
}

// Wallet/Wallet/HomeFlags.swift
import Foundation
import FlagsKit

/// What the home screen needs to know, as plain values.
/// The initial values are what we show when we know nothing: each flag's own safe value.
struct HomeFlags: Equatable, Codable {
    var showsCardBanner = false          // a promotion: skipping it costs nothing
    var allowsInstantTransfer = true     // live for everyone: hiding it would remove a feature
    var showsSpendingInsights = false    // not finished

    static let defaults = HomeFlags()

    enum Key {
        static let cardBanner = Flag<Bool>("home.card_banner")
        static let instantTransfers = Flag<Bool>("home.instant_transfers")
        static let spendingInsights = Flag<Bool>("home.spending_insights")
    }
}

extension HomeFlags {
    /// A key that is missing, or has another type, keeps its default.
    init(_ snapshot: FlagSnapshot) {
        self.init()
        showsCardBanner = snapshot.value(Key.cardBanner) ?? showsCardBanner
        allowsInstantTransfer = snapshot.value(Key.instantTransfers) ?? allowsInstantTransfer
        showsSpendingInsights = snapshot.value(Key.spendingInsights) ?? showsSpendingInsights
    }
}

protocol HomeFlagsProviding {
    /// The values from the last successful fetch, on this device. nil before the first one.
    var lastKnown: HomeFlags? { get }
    func fetch() async throws -> HomeFlags
}

/// The only place in the app that knows about the flag service.
final class RemoteHomeFlags: HomeFlagsProviding {
    init(client: any RemoteFlagsFetching, store: UserDefaults) {
        self.client = client
        self.store = store
    }

    var lastKnown: HomeFlags? {
        store.data(forKey: storeKey).flatMap { try? JSONDecoder().decode(HomeFlags.self, from: $0) }
    }

    func fetch() async throws -> HomeFlags {
        let flags = HomeFlags(try await client.fetchSnapshot())
        store.set(try JSONEncoder().encode(flags), forKey: storeKey)
        return flags
    }

    private let client: any RemoteFlagsFetching
    private let store: UserDefaults
    private let storeKey = "home.flags.lastKnown"
}

import Foundation
import Observation

@Observable
final class HomeViewModel {   // main actor: the target's default isolation
    var balance: Decimal = 1240.50
    var isBalanceHidden = false
    private(set) var flags: HomeFlags

    init(flags provider: any HomeFlagsProviding) {
        self.provider = provider
        flags = provider.lastKnown ?? .defaults   // never wait for the network to draw the screen
    }

    var showsCardBanner: Bool { flags.showsCardBanner }
    var showsInstantTransfer: Bool { flags.allowsInstantTransfer && balance > 0 }
    var showsSpendingInsights: Bool { flags.showsSpendingInsights }

    /// Once per launch. A failure keeps what's on screen, and the next appearance tries again.
    func refreshFlags() async {
        guard !hasFetched else { return }
        do {
            flags = try await provider.fetch()
            hasFetched = true
        } catch is CancellationError {
            // the screen went away: try again next time
        } catch {
            print("[Home] flag service failed, keeping the values on screen: \(error.localizedDescription)")
        }
    }

    @ObservationIgnored private let provider: any HomeFlagsProviding
    @ObservationIgnored private var hasFetched = false
}

struct RootView: View {
    @State private var selectedTab = AppTab.home
    @State private var home: HomeViewModel     // owned here, so it outlives a tab switch

    init(flags: any HomeFlagsProviding = RemoteHomeFlags(client: RemoteFlagsClient(), store: .standard)) {
        _home = State(initialValue: HomeViewModel(flags: flags))
    }

    var body: some View {
        TabView(selection: $selectedTab) {
            Tab("Home", systemImage: "house", value: AppTab.home) {
                NavigationStack {
                    HomeView(viewModel: home)
                        .task { await home.refreshFlags() }
                }
            }
        // ... the Settings tab, unchanged ...

[RemoteFlags] GET /v1/flags?app=wallet
[Home] flag service failed, keeping the values on screen: The flag service is unavailable (503).

import Foundation
import Testing
import FlagsKit
@testable import Wallet

/// The view model's seam. `lastKnown` is what this device saw last; `fetch()` returns `result`.
private final class FakeFlags: HomeFlagsProviding {
    var lastKnown: HomeFlags?
    var result: Result<HomeFlags, any Error>

    init(flags: HomeFlags?, fetching result: Result<HomeFlags, any Error>? = nil) {
        lastKnown = flags
        self.result = result ?? .success(flags ?? .defaults)
    }

    func fetch() async throws -> HomeFlags { try result.get() }
}

/// The package's seam. It's Sendable, so under main-actor default isolation the fake is nonisolated.
nonisolated private struct FakeClient: RemoteFlagsFetching {
    var result: Result<FlagSnapshot, RemoteFlagsError>
    func fetchSnapshot() async throws -> FlagSnapshot { try result.get() }
}

/// A UserDefaults of its own for each test, removed afterwards: nothing leaks into the next test.
private func withStore(_ body: (UserDefaults) async throws -> Void) async rethrows {
    let name = "WalletTests.\(UUID().uuidString)"
    let store = UserDefaults(suiteName: name)!
    defer { store.removePersistentDomain(forName: name) }
    try await body(store)
}

// The three tests from Part 1. Their bodies didn't change in the migration: only the fake did.
struct HomeViewModelTests {

    @Test func showsInstantTransferWithAPositiveBalance() {
        let viewModel = HomeViewModel(flags: FakeFlags(flags: HomeFlags(allowsInstantTransfer: true)))
        #expect(viewModel.showsInstantTransfer)
    }

    @Test func hidesInstantTransferWhenTheFlagIsOff() {
        let viewModel = HomeViewModel(flags: FakeFlags(flags: HomeFlags(allowsInstantTransfer: false)))
        #expect(!viewModel.showsInstantTransfer)
    }

    @Test func hidesInstantTransferWithAnEmptyBalance() {
        let viewModel = HomeViewModel(flags: FakeFlags(flags: HomeFlags(allowsInstantTransfer: true)))
        viewModel.balance = 0
        #expect(!viewModel.showsInstantTransfer)
    }
}

struct FlagMigrationTests {

    @Test func theFirstLaunchShowsEachFlagsDefaultWhileLoading() {
        let viewModel = HomeViewModel(flags: FakeFlags(flags: nil))
        #expect(viewModel.flags == .defaults)
        #expect(viewModel.showsInstantTransfer)       // shipped: on unless the server says off
        #expect(!viewModel.showsSpendingInsights)     // unfinished: off unless the server says on
    }

    @Test func aFailedFetchKeepsTheLastKnownValues() async {
        let lastKnown = HomeFlags(showsCardBanner: true, allowsInstantTransfer: false, showsSpendingInsights: false)
        let viewModel = HomeViewModel(flags: FakeFlags(flags: lastKnown, fetching: .failure(RemoteFlagsError.timedOut)))
        await viewModel.refreshFlags()
        #expect(viewModel.flags == lastKnown)
    }

    @Test func aFetchIsRememberedForTheNextLaunch() async {
        await withStore { store in
            let snapshot = FlagSnapshot(["home.card_banner": .bool(true), "home.instant_transfers": .bool(false),
                                         "home.spending_insights": .bool(true)])
            let today = RemoteHomeFlags(client: FakeClient(result: .success(snapshot)), store: store)
            let viewModel = HomeViewModel(flags: today)
            await viewModel.refreshFlags()

            let tomorrow = RemoteHomeFlags(client: FakeClient(result: .failure(.unavailable(status: 503))), store: store)
            #expect(tomorrow.lastKnown == viewModel.flags)
            #expect(HomeViewModel(flags: tomorrow).showsSpendingInsights)
        }
    }

    @Test func aMissingOrMistypedKeyKeepsItsDefault() async throws {
        try await withStore { store in
            let snapshot = FlagSnapshot(["home.card_banner": .bool(true), "home.instant_transfers": .string("yes")])
            let provider = RemoteHomeFlags(client: FakeClient(result: .success(snapshot)), store: store)
            let flags = try await provider.fetch()
            #expect(flags == HomeFlags(showsCardBanner: true, allowsInstantTransfer: true, showsSpendingInsights: false))
        }
    }
}