Dependencies Don't Propagate to Nested Views

[dafurman]

The Problem

I'm finding that SwiftUI views don't properly propagate dependencies to nested views. I created a demo in this gist (Drop it into a project that's got access to swift-dependencies)

To break it down more simply, if I have a structure like this:

struct InnerView: View {
	@Dependency(\.text) var text
	var body: some View {
		Text(text)
	}
}
struct OuterView: View {
	@Dependency(\.text) var text
	var body: some View { 
		Text(text)
		InnerView()
	}
}

And I want to preview my OuterView with a given text dependency:

struct OuterView_Previews: PreviewProvider {
    static var previews: some View {
        withDependencies {
            $0.text = "Injected  - withDependencies"
        } operation: {
            OuterView()
        }
    }
}

InnerView won't use my provided dependency, and will default to its previewValue.

My Current Workaround

swift-dependencies doesn't seem to propagate among views, but of course, @Environment is built for that exact purpose.
So we could lean on @Environment when we're in a world of views, and lean on @Dependency when we're in services, view models, etc. This pretty much aligns with the conclusion of this SO comment, where we have two tools for tackling DI in different parts of the app. It doesn't seem great, but AFAIK it's our best option.

A Hiccup with the Workaround

If InnerView relies on a model that needs a dependency, then adding @Dependency to that model won't be sufficient for a functional preview on OuterView, because it won't get propagated from OuterView -> InnerView -> InnerViewModel. It seems like we'd need to further lean on @Environment here, doing something like this, to have InnerView give the dependency to its model.

---

I was really hoping for @Dependency to replace the need for @Environment, but it seems like that just isn't where we are today, and I'll likely need to support injecting all of my dependencies through either the SwiftUI environment or swift-dependencies, and use some combination of both tools in order to get functional previews on these types of views.

[mbrandonw]

Hi @dafurman, the @Dependency property wrapper is not meant to be used in views if you need to be able to scope/propagate dependency changes. It is not even possible to have dependencies propagate to views without SwiftUI opening up more of its internals. By doing this:

withDependencies {
  $0.text = "Injected  - withDependencies"
} operation: {
  OuterView()
}

…you are only executing the initializer of OuterView with the dependencies altered, not the body of the view. If you use @Dependency in a view then the only benefits you get really are the live/preview/test value, but you do not get the ability to dynamically change the dependencies.

We were able to solve this problem for model objects using withDependencies(from:) because we had access to an object that we could fetch the propagated dependencies from. No such mechanism works in views.

In the end, @Dependency is only mean to be used in classes, or in situations where special support has been built directly into a tool, such as TCA.

[dafurman]

Thanks for the speedy confirmation and to ensure that I wasn't just missing something obvious! I appreciate it!