Passing Shared property to child stores

[holzerryan]

I'm struggling with setting up a shared parameter that is initialized at the root level of the app and then passed to all of the child features. My root feature is very simple for now...The state has "loggedIn" and "featureFlagData". At the root, I want to define all feature flags that will be used in the app. I also want to determine if the login screen or the app is displayed. I get stuck when trying to pass the featureFlagData shared property to the authenticated view because I have a TabView and I cannot figure out how to pass the Shared(FeatureFlagData) in as the Initial State.

@main
struct InsightsApp: App {
    @Dependency(\.featureFlagClient) var featureFlagClient
    
    @Bindable var store: StoreOf<AppFeature> = Store(
        initialState: AppFeature.State(
            featureFlagData: Shared(FeatureFlagData())
        )
    ) {
        AppFeature()
    }
    
    init() {
        store.send(.initializeFeatureFlags)
    }

    var body: some Scene {
        
        WindowGroup {
                AppView(store: store)
                    .onAppear(perform: {
                        featureFlagClient.observeAll(allFlagsObserver) { updatedFlags in
                            store.send(.featureFlagsUpdated(updatedFlags))
                        }
                    })

Then in my AppView, I have this:

struct AppView: View {
    
    @Bindable var store: StoreOf<AppFeature>
    
    var body: some View {
        Group {
            if store.loggedIn {
                AuthenticatedView(store: store.scope(
                    state: \.authenticated,
                    action: \.authenticated
                ))
            } else {
                LoginView(store: store.scope(
                    state: \.login,
                    action: \.login
                ))
            }
       }
    }
}

@Reducer
struct AppFeature {
    
//    @Reducer
//    enum Path: Equatable {
//        case login(LoginFeature)
//        case authenticated(AuthenticatedFeature)
//    }

    @ObservableState
    struct State: Equatable {
//        var path = StackState<Path.State>()
        
        @Shared var featureFlagData: FeatureFlagData
        var loggedIn: Bool = false
        
        var login = LoginFeature.State.init()
        var authenticated = AuthenticatedFeature.State.init(featureFlagData: Shared(FeatureFlagData()))
    }
    
    enum Action {
//        case path(StackAction<Path.State, Path.Action>)
        
        case featureFlagsUpdated([String: LDChangedFlag])
        case initializeFeatureFlags
        case login(LoginFeature.Action)
        case authenticated(AuthenticatedFeature.Action)
    }
    
    var body: some ReducerOf<Self> {
        Scope(state: \.login, action: \.login) {
            LoginFeature()
        }
        Scope(state: \.authenticated, action: \.authenticated) {
            AuthenticatedFeature()
        }
        Reduce { state, action in
            switch action {
            case .initializeFeatureFlags:
                // do some stuff
                return .none
                
            case .featureFlagsUpdated(let updatedFlags):
                // update flag values
                return .none
                
            case let .login(.delegate(action)):
                switch action {
                case .authenticated:
                    state.loggedIn = true
                    return .none
                }
                
            case let .authenticated(.accountSelected(.delegate(action))):
                switch action {
                case .logout:
                    state.loggedIn = false
                    return .none
                }
                
            case .login, .authenticated:
                return .none
                
//            case .path(_):
//                return .none
            }
        }
//        .forEach(\.path, action: \.path)
    }
}

How would I pass the AppFeature.state.featureFlagData to the initial state of the Authenticated and Login features?

[MaraMincho]

Hi @holzerryan

You can find information about the shared property here. As you can see, I would suggest considering how to create a new initializer in AppFeature.State instead of relying on the compiler-provided initializer. When the store for the reducer is created, the Shared property is passed as a parameter from InsightsApp, but this method doesn’t actually retain the Shared instance.
So, it would be better to either pass the shared object directly or initialize the shared property where it is needed. If you're planning to declare the shared property in InsightsApp (as per your intention), it would be better to configure the featureFlagClient in the init method instead of generating it as a dependency.

@main
struct InsightsApp: App {
    // ✅
    @Shared var featureFlagData
    @Bindable var store: StoreOf<AppFeature>
    
    init() {
        // ✅ init shared Property
        _featureFlagData = .init(.init())
        store = Store(
            initialState: AppFeature.State(
                featureFlagData: Shared(FeatureFlagData())
            )
        ) {
            AppFeature()
        }
        store.send(.initializeFeatureFlags)
    }
}

@Reducer
struct AppFeature {
  
    @ObservableState
    struct State: Equatable {
        // var path = StackState<Path.State>()
        
        @Shared var featureFlagData: FeatureFlagData
        var loggedIn: Bool = false
        
        var login = LoginFeature.State.init()
        var authenticated = AuthenticatedFeature.State.init(featureFlagData: Shared(FeatureFlagData()))
        
        init(featureFlagData: Shared<FeatureFlagData>) {
            _featureFlagData = featureFlagData
        }
    }
}

[holzerryan]

This makes sense. Thank you for the suggestion. I am going to try your suggestion and create a new initializer in the AppFeature state. I'm still learning this architecture pattern and am very impressed with its flexibility when attempting to do unique things.