Access dependency inside a dependency definition

[grdsdev]

Hey all, I'm working on a project and I started doing the following, but I'm not sure if that is safe to do and what the behavior of it.

extension DependencyA: DependencyKey {
   static var liveValue: DependencyA {
      @Dependency(\.dependencyB) var dependencyB
    
       return DependencyA {
           dependencyB.doSomething()
       }
   }
}

What's the correct way of accessing dependencies inside other dependencies?

[mbrandonw]

Yes, that is completely fine to do. We have an example of doing this in order to define the live database client for www.pointfree.co, which needs access to environment variables loaded from Heroku.

One thing to keep in mind is that currently the library does not do any circular dependency detection, so if through some chain of events DependencyB starts depending on DependencyA, you will get a crash. We may improve this later but it is not a priority right now.

[acosmicflamingo]

Let's say I'm writing a test for a Model that depends on DependencyA and DependencyA depends on DependencyB:

extension DependencyA: DependencyKey {
   static var liveValue: DependencyA {
      @Dependency(\.dependencyB) var dependencyB
    
       return DependencyA {
           dependencyB.doSomething()
       }
   }
}

struct MyModel {
  var myBool: Bool = false

   @Dependency(\.dependencyA) var dependencyA: () -> Bool

   mutating func generateTrue() {
     self.myBool = dependencyA()
   }
}

func testMyModel() {
  let myModel = withDependencies {
  } operation: {
    MyModel()
  }
  myModel.generateTrue()
  XCTAssertTrue(myModel.myBool)
}

In this test, I'd see an XCTUnimplemented error for DependencyA since I didn't add it within the withDependencies closure, but I would see nothing for DependencyB. Would there ever be a situation where this could pose a problem? Or should it be assumed that DependencyB will always work?

[mbrandonw]

In general, when working with non-"single entry point" systems, you should declare all dependencies at the top-level of the object that needs the dependencies, and not in methods, computed properties, helpers, etc. Only true single entry point systems, such as TCA, can use that style because the execution of all methods/properties/helpers is contained with in a single scope.

If you move the @Dependency to be an instance variable on MyModel it should work as you expect. I recommend reading our articles to get a deeper understanding, in particular this section of our "single entry point systems" article, as well as the dependency lifetimes article.

[acosmicflamingo]

Thanks @mbrandonw !

[acosmicflamingo]

Thanks to @mbrandonw 's advice and @tgrapperon 's approach to designing dependencies in DependenciesAdditions with the ConfigurableProxy protocol, I believe the best way to handle nested dependencies and ensure the model is a single entry-point system is to simply pass these dependencies down via the ever-so-popular dependency injection! Doing so is great it now means the the model is now a single entry-point system, and the two dependencies of your model will now throw an unimplemented error if they are not overridden during tests:

extension DependencyA: DependencyKey {
  static var liveValue: DependencyA {
    return DependencyA { dependencyB in
      dependencyB.doSomething()
    }
  }
}

struct MyModel {
  var myBool: Bool = false

   @Dependency(\.dependencyA) var dependencyA: (DependencyB) -> Bool
   mutating func generateTrue() {
     @Dependency(\.dependencyB) var dependencyB
     self.myBool = dependencyA(dependencyB)
   }
}

func testMyModel() {
  let myModel = withDependencies {
  } operation: {
    MyModel()
  }
  myModel.generateTrue()
  XCTAssertTrue(myModel.myBool)
}

This example is perhaps more pseudo-code (and useless) than it is production ready, so I will copy and paste a real use-case I'm encountering when developing my own apps. Hopefully it does a better job explaining what I mean when I say that the solution is to utilize dependency injection.

In my situation, I want to create a FontManager dependency that makes it possible to save and load a FontFamily enum. I want my dependency to interface with @tgrapperon 's UserDefaults dependency, but it seemed impossible to both include userDefaults within the FontManager model and also be able to interface with it when implementing liveValue. Most importantly, I wanted to see unimplemented errors for both $0.fontManager and $0.userDefaults if I did not override either of them during tests.

The following is probably more complicated than what others are doing, but it does solve the problem I was encountering (and it's what @tgrapperon does so it's most definitely better than whatever I thought of doing ;) ). Hopefully it makes more sense the more you stare at it :) :

extension FontManager: DependencyKey {
  public static var liveValue: FontManager { .system }
  public static var testValue: FontManager { .unimplemented }
  public static var previewValue: FontManager { .system }
}

extension DependencyValues {
  public var fontManager: FontManager {
    get { self[FontManager.self] }
    set { self[FontManager.self] = newValue }
  }
}

public struct FontManager: Sendable, ConfigurableProxy {
  @_spi(Internals) public var _implementation: Implementation

  public struct Implementation: Sendable {
    @FunctionProxy public var appFont:
      @Sendable (UserDefaults.Dependency) -> FontFamily
    @FunctionProxy public var setAppFont:
      @MainActor @Sendable (FontFamily, UserDefaults.Dependency) async -> Void
    init(
      appFont: FunctionProxy<
        @Sendable (UserDefaults.Dependency) -> FontFamily
      >,
      setAppFont: FunctionProxy<
        @MainActor @Sendable (FontFamily, UserDefaults.Dependency) async -> Void
      >
    ) {
      self._appFont = appFont
      self._setAppFont = setAppFont
    }
  }
}

extension FontManager {
  public var appFont: FontFamily {
    @Dependency(\.userDefaults) var userDefaults: UserDefaults.Dependency
    return _implementation.appFont(userDefaults)
  }

  @MainActor
  public func setAppFont(_ fontFamily: FontFamily) async -> Void {
    @Dependency(\.userDefaults) var userDefaults: UserDefaults.Dependency
    await _implementation.setAppFont(fontFamily, userDefaults)
  }
}

extension FontManager {
  public static var system: FontManager {
    let appFontKey = "com.CosmicFlamingo.FontManager.appFont"
    let appFont = LockIsolated<FontFamily?>(nil)

    // Taking the following approach saves the app from repeatedly reading from
    // UserDefaults.
    let appFontGenerator: @Sendable (UserDefaults.Dependency) -> FontFamily = { userDefaults in
      guard
        let appFont = appFont.value
      else {
        let savedFont = userDefaults.font(forKey: appFontKey) ?? .Ubuntu
        appFont.setValue(savedFont)
        return savedFont
      }
      return appFont
    }
    let _implementation = Implementation(
      appFont: .init {
        appFontGenerator
      },
      setAppFont: .init {
        { newAppFont, userDefaults in
          appFont.setValue(newAppFont)
          userDefaults.set(newAppFont, forKey: appFontKey)
          // Notify A11yClient.Publishers.appFont of update notification
          NotificationCenter.default.post(name: FontManager.appFontDidChangeNotification, object: nil)
        }
      }
    )
    return FontManager(_implementation: _implementation)
  }

  public static var unimplemented: FontManager {
    let _implementation = Implementation(
      appFont: .unimplemented(
        #"@Dependency(\.fontManager.appFont)"#
      ),
      setAppFont: .unimplemented(
        #"@Dependency(\.fontManager.setAppFont)"#
      )
    )
    return FontManager(_implementation: _implementation)
  }
}

// DependenciesAdditions.UserDefaults Integration

extension UserDefaults.Dependency {
  /// Returns the FontFamily value associated with the specified key.
  /// - Parameter key: A key in the current user defaults store.
  /// - Returns: The FontFamily value associated with the specified key, or `nil` if there is no value
  /// associated to `key`
  public func font(forKey key: String) -> FontFamily? {
    self.data(forKey: key)
      .flatMap { try? decoder.decode(FontFamily.self, from: $0) }
  }

  /// Sets the value of the specified default key to the specified FontFamily value.
  /// - Parameters:
  ///   - value: The FontFamily value to store in the user's defaults store. If the value is `nil`,
  ///   the associated value will be removed from the store.
  ///   - key: The key with which to associate the value.
  public func set(_ value: FontFamily?, forKey key: String) {
    self.set(try? encoder.encode(value), forKey: key)
  }
}

import Overture

// https://github.com/pointfreeco/swift-overture#with-and-update
private let decoder = update(JSONDecoder()) {
  $0.dateDecodingStrategy = .secondsSince1970
}
private let encoder = update(JSONEncoder()) {
  $0.dateEncodingStrategy = .secondsSince1970
}