How to Deal with Side Effects of a Shared Client Dependency?

[HeyAbdelali]

I have a shared dependency called CartClient that manages a shopping cart. The cart allows various operations such as adding a product or applying a discount. It also has a publisher property that emits operations (e.g., .addCartLine).

public struct CartClient {
    
    public var get: @Sendable () -> Cart
    public var set: @Sendable (Cart) async -> Void
    public var stream: @Sendable () -> AnyPublisher<Cart, Never>

    public init(
        get: @escaping @Sendable () -> Cart,
        set: @escaping @Sendable (Cart) async -> Void,
        stream: @escaping @Sendable () -> AnyPublisher<Cart, Never>
    ) {
        self.get = get
        self.set = set
        self.stream = stream
    }
 }

Previously, the cart was a property of the order store, and I was listening to these operations to save the cart state in the database. Now that the cart is a shared client, I'm wondering how to handle this.

        cartClient.stream()
            .map { cart in
                cart.editOperation
                    .eraseToAnyPublisher()
            }
            .print("CartOperation")
            .switchToLatest()
            .weakSink(weaklyCaptured: self, receiveValue: { strongSelf, operation in
                strongSelf.processCartOperation(operation)
            })
            .store(in: &cancellable)

Should I manage these side effects within the dependency itself, or should some parts of the application listen to these operations? What are the best practices for dealing with such side effects in a shared client dependency?

Thank you