How to handle a dependency that is using MainActor instance behind the scenes.

[klemenzagar91]

Hi. I read a few topic that I've found about tackling actors. But I dont know how to apply this thinking in my case where I used WKWebsiteDataStore.default().httpCookieStore and when that part is executed during runtime I get this error: WKWebsiteDataStore.default().httpCookieStore must be used from main thread only.

extension CookieStoreClient: DependencyKey {
    public static let liveValue = {
        let cookieStore = WKWebsiteDataStore.default().httpCookieStore
        return Self(
            allCookies: {
                return await getAllCookies(from: cookieStore)
            },
            deleteCookie: { cookie in
                return await delete(cookie, from: cookieStore)
            }
        )
    }()
}

Is it a good solution to just use WKWebsiteDataStore.default().httpCookieStore in each endpoint like this or is this just a cheap bypass? Here its possible because we have access to default() but how it would look like it we would have a regular init() and I would like that both dependency endpoints (allCookies and deleteCookie) use same instance of WKWebsiteDataStore.

extension CookieStoreClient: DependencyKey {
    public static let liveValue = Self(
        allCookies: {
            let cookieStore = await WKWebsiteDataStore.default().httpCookieStore
            return await getAllCookies(from: cookieStore)
        },
        deleteCookie: { cookie in
            let cookieStore = await WKWebsiteDataStore.default().httpCookieStore
            return await delete(cookie, from: cookieStore)
        }
    )
}

What are your thoughts on this? I will appreciate some help.

[mbrandonw]

Hi @klemenzagar91, for your use case, the second code snippet you have is just fine since there is a natural singleton (default()) to use.

In the situation where you do not have a singleton and you want an instance, you really have no choice but to create a separate endpoint on your dependency for creating the main actor object, and then you have to invoke that endpoint early on in your app's lifecycle:

extension MyDependency: DependencyKey {
  static var liveValue: Self {
    nonisolated(unsafe) var store: SomeMainActor!
    return Self(
      init: { store = await SomeMainActor() },
      fetch: { await store.fetch() },
      delete: { await store.delete() }
    )
  }
}

The nonisolated(unsafe) is necessary because we want to access the var from a @Sendable closure, but in this case it's ok because we only mutate the variable a single time in the init endpoint. If you are wanting to be able to write to store multiple times, then you would need to instead wrap store in a lock or mutex.

And the reason this is necessary is because we want you to be able to access @Dependency synchronously, and @Dependency can be used from anywhere, including off the main actor. And so it will be possible that SomeMainActor is created off the main actor, which means it can't be done synchronously.

[klemenzagar91]

I like it. Thanks for full explanation.

I hope this will also help someone else.