What is the best approach to clear navigation stack from anywhere in the app?

[Ojas-Chimane]

I have implemented an auto-logout feature in the app which gets triggered after 30 mins of device inactivity. The current solution I have implemented is to send a delegate call to the RootView(LoginStore) from any child view to clear logged in credentials and clear the stack. This works correctly and the user is navigated to the login screen.

Problem - While this approach is working correctly it is causing a lot of code duplication is all the child views to have a .send(.delegate(.clearCredentials)) delegate talk to the LoginStore to clear the stack.

Question - Is there any alternative I can use to talk to the LoginStore from anywhere in the app to clear the stack?

@Reducer
struct LoginStore: Sendable {

    @Reducer(state: .equatable)
    public enum Path {
        case home(HomeStore)
        case printLabel(PrintLabelStore)
        case orderSetup(OrderPickSetupStore)
    }
    
    @ObservableState
    struct State: Equatable {
        var userEmail: String = ""
        var userPassword: String = ""

        var path = StackState<Path.State>()
    }
    
    enum Action: BindableAction {
        case popToRoot
        case goBackToScreen(id: StackElementID)
        
        case path(StackAction<Path.State, Path.Action>)
    }
    
    var body: some Reducer<State, Action> {
        BindingReducer()
        Reduce { state, action in
            switch action {
            case let .path(.element(_, .home(.delegate(delegateAction)))):
                
                switch delegateAction {
                case .printLabel:
                    state.path.append(.printLabel(PrintLabelStore.State()))
                case .orderPickSetup:
                    state.path.append(.orderSetup(OrderPickSetupStore.State()))
                case .clearCredentials:  // Duplicate
                    clearCredentialsFromKeychain(&state)
                    return .run { send in await send(.popToRoot) }
                }
                
                return .none
                
            case let .path(.element(_, .orderSetup(.delegate(delegateAction)))):
                
                switch delegateAction {
                case .scanOrderView(let orderSetup):
                    state.path.append(.scanOrderBarcode(ScanOrderBarcodeStore.State(orderSetup: orderSetup)))
                case .rdsOrdersView(let orderSetup):
                    state.path.append(.rdsOrders(RdsOrderListStore.State(orderSetup: orderSetup)))
                case .clearCredentials:    // Duplicate 
                    clearCredentialsFromKeychain(&state)
                    return .run { send in await send(.popToRoot) }
                }
                return .none
                
            case .popToRoot:
                state.path.removeAll()
                return .none
                
            case .goBackToScreen(id: let id):
                state.path.pop(to: id)
                return .none
                
            case .path:
                return .none
            
            }
        }
        .forEach(\.path, action: \.path)
    }
}

@Reducer
public struct HomeStore {
    @ObservableState
    public struct State: Equatable {
        @Presents var alert: AlertState<Action.Alert>?
    }
    
    public enum Action {
        case alert(PresentationAction<Alert>)
        case delegate(Delegate)
        case labelPrintButtonTapped
        case pickOrderButtonTapped
        case logoutButtonTapped
    }
    
    @CasePathable
    public enum Delegate {
      case printLabel
      case orderPickSetup
      case clearCredentials
    }
    
    public var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .labelPrintButtonTapped:
                return .send(.delegate(.printLabel))
                
            case .pickOrderButtonTapped:
                return .send(.delegate(.orderPickSetup))
                
            case .logoutButtonTapped:
                return .send(.delegate(.clearCredentials))
                
            case .delegate(_):
                return .none
                
            case .alert:
                return .none
            }
        }
        .ifLet(\.$alert, action: \.alert)
    }
}

[mbrandonw]

Question - Is there any alternative I can use to talk to the LoginStore from anywhere in the app to clear the stack?

It is perfectly fine to using global communication mechanisms like NotificationCenter for things like this. A feature can post a notification from an effect, and any other feature can subscribe to notifications in an effect. It works perfectly fine and it is completely testable too.

[Ojas-Chimane]

Thanks