Passing Data Between Reducers

[CJiu01]

Hi,

I’m currently working on a logic where clicking the logout button in the settings view transitions the user to the login view. When the .logoutButtonTapped case is executed, I want to change the appReducer state to loggedOut. However, since setting and login are not in a parent-child relationship, I’m unsure how to pass the action between them.

Can you help me figure out how to achieve this?

---

Code

SettingReducer

@Reducer
struct SettingReducer {
    @ObservableState
    struct State {
        @Shared(.appStorage("permission")) var permission = false
    }
    
    enum Action: BindableAction {
        case binding(BindingAction<State>)
        case logoutButtonTapped
    }
    
    var body: some ReducerOf<Self> {
        BindingReducer()
        Reduce { state, action in
            switch action {
            case .logoutButtonTapped:
                return .run { send in
                // ✅
                }
            default:
                return .none
            }
        }
    }
}

AppReducer

@Reducer
struct AppReducer {
    @ObservableState
    enum State {
        case initial
        case loggedOut(LoginReducer.State)
        case loggedIn(HomeReducer.State)
        
        init() {
            self = .initial
        }
    }
    
    enum Action {
        case initialize
        case initResponse(Result<Void, Error>)
        case login(LoginReducer.Action)
        case home(HomeReducer.Action)
        case setting(SettingReducer.Action)
        case logout
    }
    
    @Dependency(\.localNotificationClient) var localNotificationClient
    @Dependency(\.studentClient) var studentClient
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .initialize:
                return .run { send in
                    await send(.initResponse(Result {
                        let _ = try await studentClient.getSaintInfo()
                    }))
                }
            case .initResponse(.success):
                state = .loggedIn(HomeReducer.State())
                return .none
            case .initResponse(.failure(let error)):
                debugPrint(error)
                state = .loggedOut(LoginReducer.State())
                return .none
            case .login(.loginResponse(.success)):
                state = .loggedIn(HomeReducer.State())
                return .none
            case .logout:
                debugPrint("AppReducer: loggedout")
                // ✅
                return .none
            default:
                return .none
            }
        }
        .ifCaseLet(\.loggedOut, action: \.login) {
            LoginReducer()
        }
        .ifCaseLet(\.loggedIn, action: \.home) {
            HomeReducer()
        }
    }
}

AppView

struct AppView: View {
    @Perception.Bindable var store: StoreOf<AppReducer>
    
    var body: some View {
        switch store.state {
        case .initial:
            SplashView()
                .onAppear {
                    store.send(.initialize)
                }
        case .loggedOut:
            if let store = store.scope(state: \.loggedOut, action: \.login) {
                LoginView(store: store)
            }
        case .loggedIn:
            if let store = store.scope(state: \.loggedIn, action: \.home) {
                HomeView(store: store, viewModel: DefaultSaintHomeViewModel(), isLoggedIn: $isLoggedIn)
            }
        }
    }
}

[mbrandonw]

Hi @CJiu01, this kind of far reaching communication between features can still be done with Notification Center if you want. The child feature posts a notification and the parent feature listens for notifications inside a long-living effect.

While we don't have a case study for this exact situation (that of logging out), we do have a case study for interacting with notifications:

swift-composable-architecture/Examples/CaseStudies/SwiftUICaseStudies/03-Effects-LongLiving.swift

Lines 36 to 40 in 0a9d1d9

	return .run { send in
	for await _ in await self.screenshots() {
	await send(.userDidTakeScreenshotNotification)
	}
	}

This case study puts a dependency in front of the Notification Center:

swift-composable-architecture/Examples/CaseStudies/SwiftUICaseStudies/03-Effects-LongLiving.swift

Lines 59 to 61 in 0a9d1d9

	NotificationCenter.default
	.notifications(named: UIApplication.userDidTakeScreenshotNotification)
	.map { _ in }

But you could also use NotificationCenter directly in your reducer. The only thing it will complicate is running tests in parallel, but you can always run them in serial.