How to inject a dependency initialized based on a state value

[omaralbeik]

First, as usual thank you for the great work 👏👏👏

I’m working on an app where I need to override a dependency based on a state value, the dependency will be used in a child reducer later on.
I don't know how and when to initialize the dependency

---

Here’s a quick example:

Imagine a simple app that consists of the following service and three modules

Book service

A service required to fetch book titles for a given user:

protocol BookService {
  func fetchTitles() async throws -> [String]
}

class UnimplementedBookService: BookService {
  init() {}

  func fetchTitles() async throws -> [String] {
    XCTFail("Unimplemented")
    return []
  }
}

class UserBookService: BookService {
  let user: User

  init(user: User) {
    self.user = user
  }

  func fetchTitles() async throws -> [String] {
    // fetch titles for the current user.
  }
}

private enum BookServiceKey: DependencyKey {
  static let liveValue: BookService = UnimplementedBookService()
}

extension DependencyValues {
  var bookService: any BookService {
    get {
      self[BookServiceKey.self]
    }
    set {
      self[BookServiceKey.self] = newValue
    }
  }
}

---

Unauthenticated feature

Unauthenticated user logic, eg. login, register, forget password, and all features related to signing in a user:

struct Unauthenticated: Reducer {
  struct State { ... }

  enum Action { ... }

  var body: some ReducerOf<Self> { ... }
}

---

Authenticated feature

All logic related to the authenticated user:

struct Authenticated: Reducer {
  @Dependency(\.bookService) var bookService

  struct State { ... }

  enum Action { ... }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      // Use bookService that is initialized with current user
      // Assuming the feature can not be loaded without an authenticated user
    }
  }
}

---

Main

The main module that loads when the app lunches, determines what flow to continue with based on authentication state.

struct Main: Reducer {
  enum State {
    case unknown
    case unauthenticated(Unauthenticated.State)
    case authenticated(Authenticated.State)
  }

  enum Action {
    case loadCurrentUser
    case unauthenticated(Unauthenticated.Action)
    case authenticated(Authenticated.Action)
  }

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .loadCurrentUser:
        // Called once when the app launches to load current user.
        if let user = ... {
          // Need to override the the book service at this point for the authenticated user
          state = .authenticated(.init())
        } else {
          state = .unauthenticated(.init())
        }
        return .none

      case .unauthenticated, .authenticated:
        return .none
      }
    }
    Scope(
      state: /State.unauthenticated,
      action: /Action.unauthenticated,
      child: Unauthenticated.init
    )
    Scope(
      state: /State.authenticated,
      action: /Action.authenticated,
      child: Authenticated.init
    )
    .dependency(\.bookService, UserBookService(user: ???))
  }
}

[kamcma]

Have a read through #1969.

[omaralbeik]

This is exactly what I'm looking for 😍

[omaralbeik]

Thanks @kamcma!