How to handle cancellation when logging out

[Scocher]

In the base of our app we have a switch case to handle launch, login and main.
When a user is logged out, either on tappin logout or session becomes inactive, this switches states from Main to Login.
If an action is running in the background when this happens, we get the error:
"A "Scope" at "View" received a child action when child state was set to a different case. …"
Is there a way to cancel all actions or do we need to keep track of all actions and cancel them all when user goes back to login state?

[kamcma]

Is there a way to cancel all actions or do we need to keep track of all actions and cancel them all when user goes back to login state?

You don't need to cancel actions, you need to cancel effects. Actions are sent synchronously and not cancellable.

TCA's navigation tools automatically cancel effects from presented views when those views are dismissed. If you present your logged-in views using the TCA navigation tools by navigating away when the user logs out, all in-flight and long-running effects from those presented views will be cancelled.

If you aren't using TCA navigation tools, yes, you need handle effect cancellation manually.

(Caveat: I believe only the ifLet reducer tools for optional state cancel effects; the switch-based ones for enum state do not for the time being. So you'd want to use the former. But even for enum root state of launch/login/main, you can just do a few ifLets.)

[kamcma]

I mean, to be clear, you do not have to use the TCA presentation tools. You can handle effect cancellation manually:

import ComposableArchitecture
import SwiftUI

struct Foo: Reducer {
  struct State: Equatable { }

  enum Action {
    case onAppear
    case onDisappear
  }

  private enum CancelID {
    case onAppear
  }

  var body: some ReducerOf<Self> {
    Reduce { _, action in
      switch action {

      case .onAppear:
        return .run { send in
          // some long-lived effect
        }
        .cancellable(id: CancelID.onAppear)

      case .onDisappear:
        return .cancel(id: CancelID.onAppear)

      }
    }
  }
}

struct FooView: View {
  let store: StoreOf<Foo>

  var body: some View {
    WithViewStore(self.store, observe: { $0 }) { viewStore in
      EmptyView()
        .onAppear { viewStore.send(.onAppear) }
        .onDisappear { viewStore.send(.onDisappear) }
    }
  }
}

But, in a non-trivial application, doing this for all views becomes tedious and error-prone. It is a super-power of the TCA navigation tools that they, as part of their implementation, tag all effects emitted from features presented with them and cancel them when those features disappear.

[Jaeki-Lee]

Would I know the way how to cancel multiple cancellableID?
It seems not work

case .cancelEffect:
        for cancelID in CancelID.allCases {
          let _ = Effect<Any>.cancel(id: cancelID)
        }
        return .none

Furthermore, I like to know how to cancel without return?

Reduce { state, action in
      switch action {
      case .binding(\.$userBio):
      //It is not work
        let _ = Effect<Any>.cancel(id: CancelID.userbio)
        let userbio = state.userBio

        if !userbio.isEmpty {
          return .run { send in
            await send(
              .validateBio(
                TaskResult(catching: {
                  try await accountServiceClient.validateUserBio(
                    userbio
                  )
                })
              )
            )
          }
          .debounce(
            id: CancelID.userbio,
            for: 0.5,
            scheduler: mainQueue
          )
        } 

[kamcma]

It seems not work

case .cancelEffect:
        for cancelID in CancelID.allCases {
          let _ = Effect<Any>.cancel(id: cancelID)
        }
        return .none

All those cancellation effects you're creating in the loop are being immediately lost and you're only returning the .none effect. If you want to return a bunch of cancellation effects at once, you need to merge them:

return CancelID.allCases.reduce(.none) { effect, cancelID in
  effect.merge(with: .cancel(id: cancelID))
}

There's a few overloads of merge depending on what you need.

Cancellation is an effect in itself, so you cannot do it from the body of reducer, you can only do it by returning a cancel effect. But using merge (and other composition operators, like concatenate), you compose the effects you need so you're not really limited by the single effect return value.

[jshier]

It's probably simpler to directly map from allCases (untested).

return .merge(CancelID.allCases.map { .cancel(id: $0) })

[kamcma]

Yes, thank you. That's what I was trying to come up with but my brain only wanted to do the longer way. 😂

[mariob]

I've actually observed, which I believe is SwiftUI bug, when using TabViews.

For example if you have two tabs, Home and Settings.

• In the Home view you have a task modifier which sends and action to the Home reducer.
• In the Settings page you have a logout button.

If you go to the settings view and tap "Logout" the bug will make the Home view's task modifier run again before taking down the view, which in turn will send an action to the Home reducer which is not active anymore because of the state switch.

[Scocher]

This is very close to the exact problem I have, but instead of task modifier running again, it is a api call happing sometimes in the home reducer.

[atsixian]

@mariob I'm having the same problem. Do you find any workaround?