Triggering effects from child

[arkulpaKonstantin]

We are currently working on an App that needs to trigger some functionality in the root reducer from many child reducers and child of child of child ... reducers.

To handle this we used to listen to all the child actions and then trigger the functionality, but as that got really confusing and a lot of boilerplate for every new child action we added something like the dismiss functionality for this case.

I thought I would share this and suggest to make it more general with some hashable ID or so.

One issue we ran into is that in tests the effect is expected to finish. But one can not for now do that so we have to use skipInFlightEffects.

Here is our code. (As you may guess the functionality we need has to do with the parent reducer doing a restart 😅)
The effect:

import ComposableArchitecture

/// An effect that restarts the application.
///
/// Execute this in the effect returned from a reducer in order to restart the whole application:
///
/// ```swift
/// @Reducer
/// struct ChildFeature {
///   struct State { /* ... */ }
///   enum Action {
///     case logoutButtonTapped
///     // ...
///   }
///   @Dependency(\.restart) var restart
///   var body: some Reducer<State, Action> {
///     Reduce { state, action in
///       switch action {
///       case .logoutButtonTapped:
///         return .run { _ in await self.restart() }
///       // ...
///       }
///     }
///   }
/// }
/// ```
///
/// This operation works by finding the nearest parent feature that uses the `.restartAction(_ restartAction: Action)` operator and
/// sending the specified restart action to that parent reducer.
///
/// > Warning: The `@Dependency(\.restart)` tool only works for features that are children of parents using
/// > the `restartAction` operator. If no parent feature is found calling the restart has no effect.
/// >
/// > If you are testing a child feature in isolation that makes use of `@Dependency(\.restart)`
/// > then you will need to override the dependency. You can even mutate
/// > some shared mutable state inside the `restart` closure to confirm that it is indeed invoked.
public struct RestartEffect: Sendable {
    var restart: (@MainActor @Sendable () -> Void)?

    @MainActor
    public func callAsFunction() async {
        self.restart?()
    }
}

extension RestartEffect {
    public init(_ restart: @escaping @MainActor @Sendable () -> Void) {
        self.restart = restart
    }
}

private enum RestartEffectKey: DependencyKey {
    static let liveValue = RestartEffect()
    static let testValue = RestartEffect()
}

extension DependencyValues {
    /// An effect that restarts the application.
    ///
    /// See the documentation of ``RestartEffect`` for more information.
    public var restart: RestartEffect {
        get { self[RestartEffectKey.self] }
        set { self[RestartEffectKey.self] = newValue }
    }
}

The reducer modifier:

import Combine
import ComposableArchitecture

public struct RestartEffectId: Hashable, Sendable {
    public init() {}
}

public struct RestartReducer<Base: Reducer>: Reducer {
    @usableFromInline
    let base: Base

    @usableFromInline
    let restartAction: Base.Action

    @usableFromInline
    init(base: Base, restartAction: Base.Action) {
        self.base = base
        self.restartAction = restartAction
    }

    @inlinable
    public func reduce(
        into state: inout Base.State, action: Base.Action
    ) -> Effect<Base.Action> {
        let subject = PassthroughSubject<Base.Action, Never>()

        let restartEffect = Effect<Base.Action>.publisher {
            subject
        }
        .cancellable(id: RestartEffectId(), cancelInFlight: true)

        let baseEffect = self.base
            .dependency(
                \.restart,
                RestartEffect {
                    subject.send(restartAction)
                }
            )
            .reduce(into: &state, action: action)

        return .merge([restartEffect, baseEffect])
    }
}

extension Reducer {
    @inlinable
    @warn_unqualified_access
    public func restartAction(_ restartAction: Self.Action) -> RestartReducer<Self> {
        RestartReducer(base: self, restartAction: restartAction)
    }
}

The root reducer then just adds this line:

.restartAction(.restart)

Then then all the children can use the dependency like so:

@Dependency(\.restart) var restart

and simply restart the root reducer by returning a run effect that calls the restart:

return .run { send in
    await restart()
}