Scope of ifLet without id

[jaanussiim]

I have an application that uses main navigation in UIKit with SwiftUI views embedded. I'm scoping the destination in the view controller

store.scope(state: \.pushDestination?.campaigns, action: \.pushDestination.campaigns)
            .ifLet(
                then: {
                    campaignsStore in                    
                    self.present(campaigns: campaignsStore) // push in navigation controller
                }
            )
            .store(in: &disposeBag)

This creates a scope without id.

When using this store in target view controllers embedded SwiftUI view, I get a runtime warning when scoping for sheet

        .sheet(
           item: $store.scope(state: \.destination?.createExpansion, action: \.destination.createExpansion),
           content: {
               store in
               
               NavigationStack(
                   root: {
                       CreateExpansionView(store: store)
                   }
               )
           }
       )

Scoping from uncached .... is not compatible with observation. Ensure all store scoping operations in your application have been updated to take key paths and case key paths instead of transform functions, which have been deprecated.

Everything is upgraded to 1.5 and is using @Reducer macro and keypath actions. These features are also using @ObservableState

[mbrandonw]

Hi @jaanussiim, this warning should only happen if there is a store somewhere up the chain that was created from a scope that did not use key paths. Are you certain that all stores are using the modern form of scoping?

If this is a real issue, could you try coming up with a minimal reproducing project that demonstrates the behavior?

[jaanussiim]

import Combine
import ComposableArchitecture
import SwiftUI
import UIKit

struct ContentView: View {
    var body: some View {
        ToSwiftUI {
            UINavigationController(
                rootViewController: RootViewController()
            )
            
        }
        .padding()
    }
}

#Preview {
    ContentView()
}

public class RootViewController: UIViewController {
    private lazy var store = Store(initialState: Root.State(), reducer: Root.init)
    private lazy var disposeBag = Set<AnyCancellable>()
    
    public override func viewDidLoad() {
        super.viewDidLoad()
        
        let hosting = UIHostingController(
            rootView: ParentView(
                store: store
            )
        )
        
        addChild(hosting)
        view.addSubview(hosting.view)
        hosting.view.translatesAutoresizingMaskIntoConstraints = false
        hosting.view.leadingAnchor.constraint(equalTo: view.leadingAnchor).isActive = true
        hosting.view.topAnchor.constraint(equalTo: view.topAnchor).isActive = true
        hosting.view.trailingAnchor.constraint(equalTo: view.trailingAnchor).isActive = true
        hosting.view.bottomAnchor.constraint(equalTo: view.bottomAnchor).isActive = true
        
        store.scope(state: \.destination?.child, action: \.destination.child).ifLet {
            [weak self]
            
            store in
            
            guard let self = self else {
                return
            }
            
            let child = ChildViewController()
            child.store = store
            self.navigationController?.pushViewController(child, animated: true)
        }
        .store(in: &disposeBag)
    }
    
    public override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        
        store.send(.onAppear)
    }
}

public class ChildViewController: UIViewController {
    var store: StoreOf<Child>!
    
    public override func viewDidLoad() {
        super.viewDidLoad()
        
        let hosting = UIHostingController(
            rootView: ChildView(
                store: store
            )
        )
        
        addChild(hosting)
        view.addSubview(hosting.view)
        hosting.view.translatesAutoresizingMaskIntoConstraints = false
        hosting.view.leadingAnchor.constraint(equalTo: view.leadingAnchor).isActive = true
        hosting.view.topAnchor.constraint(equalTo: view.topAnchor).isActive = true
        hosting.view.trailingAnchor.constraint(equalTo: view.trailingAnchor).isActive = true
        hosting.view.bottomAnchor.constraint(equalTo: view.bottomAnchor).isActive = true
    }
}

public struct ParentView: View {
    let store: StoreOf<Root>
    
    public var body: some View {
        VStack {
            Button(action: { store.send(.tappedChild) }, label: { Text("Button") })
        }
    }
}

@Reducer
public struct Root {
    @ObservableState
    public struct State {
        @Presents var destination: Destination.State?
    }
    
    public enum Action {
        case onAppear
        case tappedChild
        
        case destination(PresentationAction<Destination.Action>)
    }
    
    public var body: some ReducerOf<Self> {
        Reduce {
            state, action in
            
            switch action {
            case .onAppear:
                state.destination = nil
                return .none
            
            case .tappedChild:
                state.destination = .child(Child.State())
                return .none
                
            case .destination:
                return .none
            }
        }
        .ifLet(\.$destination, action: \.destination) {
            Destination()
        }
    }
    
    @Reducer
    public struct Destination {
        @ObservableState
        public enum State {
            case child(Child.State)
        }
        
        public enum Action {
            case child(Child.Action)
        }
        
        public var body: some ReducerOf<Self> {
            Scope(state: \.child, action: \.child) {
                Child()
            }
        }
    }
}

struct ChildView: View {
    @Bindable var store: StoreOf<Child>
    
    var body: some View {
        Text("ChildView")
            .sheet(
                item: $store.scope(state: \.destination?.sheet, action: \.destination.sheet),
                content: {
                    store in
                    
                    SheetView(store: store)
                }
            )
    }
}

@Reducer
public struct Child {
    @ObservableState
    public struct State {
        @Presents var destination: Destination.State?
    }
    
    public enum Action {
        case destination(PresentationAction<Destination.Action>)
    }
    
    public var body: some ReducerOf<Self> {
        Reduce {
            state, action in
            
            switch action {
            case .destination:
                return .none
            }
        }
        .ifLet(\.$destination, action: \.destination) {
            Destination()
        }
    }
    
    @Reducer
    public struct Destination {
        @ObservableState
        public enum State {
            case sheet(Sheet.State)
        }
        
        public enum Action {
            case sheet(Sheet.Action)
        }
        
        public var body: some ReducerOf<Self> {
            Scope(state: \.sheet, action: \.sheet) {
                Sheet()
            }
        }
    }
}

struct SheetView: View {
    let store: StoreOf<Sheet>
    var body: some View {
        Text("Grandchild")
    }
}

@Reducer
public struct Sheet {
    @ObservableState
    public struct State {
        
    }
    
    public enum Action {
        
    }
    
    public var body: some ReducerOf<Self> {
        Reduce {
            state, action in
            
            return .none
        }
    }
}

public struct ToSwiftUI: UIViewControllerRepresentable {
    private let viewController: () -> UIViewController
    
    public init(viewController: @escaping () -> UIViewController) {
        self.viewController = viewController
    }
    
    public func makeUIViewController(context: Context) -> UIViewController {
        self.viewController()
    }
    
    public func updateUIViewController(_ uiViewController: UIViewController, context: Context) {
    }
}

[mbrandonw]

Hi @jaanussiim, thanks for the repro. It's a problem with Store.ifLet and we will look into it.

[mbrandonw]

Btw this was fixed recently so if you pull the newest observation-beta the warnings should go away.

[jaanussiim]

I was keeping a very close eye on the fix branch and checked it out when it was merged. Thanks!