Workflow with this library

[zveljkovic]

As a DI library this is great thing to have when developing the mobile app. I am looking for a proper way to use it when working with Swift UI.

Current approach

1. Created class NetworkService and class NetworkModel: ObservableObject. Both registered as singletons. Reasoning was that I can inject only Model when I need to observe the state. For example networkConnected property from NetworkModel is observed on RootView and shows the current state. Also I have AuthService/Model
2. I tried making a single ViewModel for the View and use Injected or InjectedObject inside view model but this triggers a message "Accessing StateObject's object without being installed on a View. This will create a new instance each time" and then observing InjectedObject does not work

class RootViewModel: ObservableObject {
    ...
    @Injected(\.networkService) private var networkService
    @InjectedObject(\.networkModel) private var networkModel
    ...

struct RootView: View {
    @StateObject var model = RootViewModel()

3. Moving InjectedObject inside the view start works but then I also need to move the services and functionality to the view too

struct RootView: View {
    @StateObject var model = RootViewModel()
    @InjectedObject(\.networkModel) private var networkModel
    @InjectedObject(\.authModel) private var authModel

class RootViewModel: ObservableObject {
    @Injected(\.authService) private var authService
....
    
    func appear() {
...
// THIS LINE ERRORS as authModel is now injected in view 
        if authModel.currentUser == nil { 
            path.append("auth")
        } else {
            path.append("list")
        }
    }
}

4. So now everything start being in the view and it will become too much of code in one place

Is there some general guide on how to structure the app with SwiftUI and this library? I would really like that I can inject everything in the view model (both Service and ServiceModel classes) and to observe both injected models and/or computed properties (getter functions) and also have a code that triggers updates in ViewModel so I can adjust the state. But for now this eludes me...

EDIT
Figured out a way that is better then above but it relies on singleton implementation. It works by putting the same dep inside the view model and the view. (I have merged service model classes into service class). As long as the observable state inside the view, it doesn't care from where it is changed. That allowed to inject same dependency into ViewModel class and use state and functions from there.

class RootViewModel: ObservableObject {
    @Injected(\.log) private var log
    @Injected(\.networkService) private var networkService
    @Injected(\.authService) private var authService
    @Published var path = NavigationPath()

struct RootView: View {
    @InjectedObject(\.authService) private var authService
    @InjectedObject(\.networkService) private var networkService
    @StateObject var model: RootViewModel = RootViewModel()