The Composable Architecture (TCA): SwiftUI için Modern Mimari

1import ComposableArchitecture
2 
3// 1. State - Ekranın tüm durumu
4@ObservableState
5struct CounterFeature: Reducer {
6    struct State: Equatable {
7        var count = 0
8        var isLoading = false
9        var fact: String?
10    }
11 
12    // 2. Action - Kullanıcı eylemleri ve sistem event'leri
13    enum Action {
14        case incrementButtonTapped
15        case decrementButtonTapped
16        case factButtonTapped
17        case factResponse(String)
18    }
19 
20    // 3. Dependencies
21    @Dependency(\.numberFact) var numberFact
22 
23    // 4. Reducer - State'i action'a göre güncelle
24    var body: some ReducerOf<Self> {
25        Reduce { state, action in
26            switch action {
27            case .incrementButtonTapped:
28                state.count += 1
29                state.fact = nil
30                return .none
31 
32            case .decrementButtonTapped:
33                state.count -= 1
34                state.fact = nil
35                return .none
36 
37            case .factButtonTapped:
38                state.isLoading = true
39                return .run { [count = state.count] send in
40                    let fact = try await numberFact.fetch(count)
41                    await send(.factResponse(fact))
42                }
43 
44            case .factResponse(let fact):
45                state.isLoading = false
46                state.fact = fact
47                return .none
48            }
49        }
50    }
51}
52 
53// 5. View
54struct CounterView: View {
55    let store: StoreOf<CounterFeature>
56 
57    var body: some View {
58        VStack(spacing: 16) {
59            HStack {
60                Button("-") { store.send(.decrementButtonTapped) }
61                Text("\(store.count)")
62                    .font(.largeTitle)
63                Button("+") { store.send(.incrementButtonTapped) }
64            }
65 
66            Button("Get Fact") { store.send(.factButtonTapped) }
67                .disabled(store.isLoading)
68 
69            if let fact = store.fact {
70                Text(fact)
71                    .padding()
72            }
73        }
74    }
75}

1// App entry point
2@main
3struct MyApp: App {
4    let store = Store(initialState: AppFeature.State()) {
5        AppFeature()
6    }
7 
8    var body: some Scene {
9        WindowGroup {
10            AppView(store: store)
11        }
12    }
13}

1// Dependency tanımla
2struct NumberFactClient {
3    var fetch: @Sendable (Int) async throws -> String
4}
5 
6extension NumberFactClient: DependencyKey {
7    static let liveValue = NumberFactClient(
8        fetch: { number in
9            let (data, _) = try await URLSession.shared.data(
10                from: URL(string: "http://numbersapi.com/\(number)")!
11            )
12            return String(data: data, encoding: .utf8) ?? ""
13        }
14    )
15 
16    static let testValue = NumberFactClient(
17        fetch: { "\($0) is a great number!" }
18    )
19}
20 
21extension DependencyValues {
22    var numberFact: NumberFactClient {
23        get { self[NumberFactClient.self] }
24        set { self[NumberFactClient.self] = newValue }
25    }
26}

1@ObservableState
2struct AppFeature: Reducer {
3    struct State: Equatable {
4        var tab = Tab.home
5        var home = HomeFeature.State()
6        var profile = ProfileFeature.State()
7        var settings = SettingsFeature.State()
8    }
9 
10    enum Action {
11        case tabChanged(Tab)
12        case home(HomeFeature.Action)
13        case profile(ProfileFeature.Action)
14        case settings(SettingsFeature.Action)
15    }
16 
17    var body: some ReducerOf<Self> {
18        Reduce { state, action in
19            switch action {
20            case .tabChanged(let tab):
21                state.tab = tab
22                return .none
23            default:
24                return .none
25            }
26        }
27        // Child reducer'ları compose et
28        Scope(state: \.home, action: \.home) { HomeFeature() }
29        Scope(state: \.profile, action: \.profile) { ProfileFeature() }
30        Scope(state: \.settings, action: \.settings) { SettingsFeature() }
31    }
32}

1@MainActor
2func testCounter() async {
3    let store = TestStore(initialState: CounterFeature.State()) {
4        CounterFeature()
5    } withDependencies: {
6        $0.numberFact.fetch = { "\($0) is a nice number" }
7    }
8 
9    // Increment
10    await store.send(.incrementButtonTapped) {
11        $0.count = 1
12    }
13 
14    // Get fact
15    await store.send(.factButtonTapped) {
16        $0.isLoading = true
17    }
18 
19    // Fact response
20    await store.receive(.factResponse("1 is a nice number")) {
21        $0.isLoading = false
22        $0.fact = "1 is a nice number"
23    }
24}

1@Reducer
2struct ContactsFeature {
3    @ObservableState
4    struct State: Equatable {
5        var contacts: [Contact] = []
6        @Presents var destination: Destination.State?
7    }
8 
9    enum Action {
10        case addButtonTapped
11        case destination(PresentationAction<Destination.Action>)
12    }
13 
14    @Reducer
15    enum Destination {
16        case addContact(AddContactFeature)
17        case editContact(EditContactFeature)
18        case alert(AlertState<AlertAction>)
19    }
20 
21    var body: some ReducerOf<Self> {
22        Reduce { state, action in
23            switch action {
24            case .addButtonTapped:
25                state.destination = .addContact(AddContactFeature.State())
26                return .none
27            case .destination:
28                return .none
29            }
30        }
31        .ifLet(\.$destination, action: \.destination)
32    }
33}