Capturing non-nil value of dependency variables inside Sendable closures

[tobitech]

I'm thinking of a way to go about designing dependencies whose live implementation requires an initial setup/configuration of a 3rd party framework.
In my case I have a DataStoreClient whose live implementation uses Realm SDK for loading and storing data.

I need to configure a Realm object that is accessible to other closures in the client.
I achieved this with an optional variable that was initialised in the setup closure prior to migrating from Effect<> to async-await which also meant I needed to mark the closures with @sendable.

The moment I do that I start getting the error Reference to captured var 'realm' in concurrently-executing code which was expected so I captured the mutable variable in the closure.
The problem I'm having now is that when the instance of the client is initialised, the closures capture a nil value of the realm variable and I'm not able to access the non-nil value after setupConfigurations closure is called.

Interface

public struct DataStoreClient {
    public var setupConfigurations: (String) -> Void
    public var saveObject: @Sendable (ObjectData)  async throws -> ObjectData
    ...
    public init(
            setupConfigurations: @escaping (String) -> Void,
            saveObject: @escaping @Sendable (TransactionData) async throws -> TransactionData
    ) {
            self.setupConfigurations = setupConfigurations
            self.saveTransaction = saveTransaction
            ...
    }
}

Live Implementation

extension DataStoreClient: DependencyKey {
  public static var liveValue: Self {
    var realm: Realm?
		
    return Self(
      setupConfigurations: { configParams in
        realm = try Realm(configuration: configParams)
      },
      saveTransaction: { [realm] transaction in
      // captured realm is nil since it was captured at point of initialisation.
        try realm?.write {
            realm?.add(object)
        }
      }
}

I don't know how you guys have approached this problem when designing dependencies with structs, would appreciate some help and suggestions.

[PierreCapo]

Hello @tobitech ,
I think this is an interesting question, since:

1. this scenario happens quite often
2. it is not straight-forward from the documentation on how to achieve this pattern.

You can take an idea from: https://github.com/pointfreeco/isowords/blob/main/Sources/ApiClientLive/LiveKey.swift#L15
The live implementation instantiates a Session object that is then shared (captured) by all exposed functions of your live client.
This allows you to "configure" your client as you would do inside an init() function.
Hope it helps 🙌

[tobitech]

Thank you for the reference. I was able to refactor my dependency to use that pattern and get it to work but still with certain limitations.

[phi161]

I'm wondering, with this setup is that Session object ever going to be deallocated?