Complex use of multiple dependencies and how to model it?

[oliverfoggin]

We have a reducer and a view in our app that can be presented from two different places.

Lets say it is a chat view with a stream of incoming messages and a function to send a message. Something like...

var messagesStream: () async throws -> AsyncStream<[ChatMessagePayload]>
var sendChatMessage: (String) async throws -> Void

Obvs this goes through a dependency ... BUT... the dependency in each case is quite complex and cutting it down just for Chat stuff wouldn't really be possible.

So for now we've created a ChatReducer with an init that takes these functions as parameters.

That way, the different places that use the ChatView and ChatReducer can use their own dependency and pass in functions to the ChatReducer use it.

i.e.

// in FeatureOneWithChat this is in the Reducer for the `Destination` when the `ChatView` is shown.
Scope(state: /State.chat, action: /Action.chat) {
  @Dependency(\.featureOneDependency) var featureOneDependency

  ChatScreenCore(
    messagesStream: {
      return try await featureOneDependency.eventMessages().compactMap { message in
        guard case let .chatMessagesUpdated(list) = message else { return nil }
        return list
      }.eraseToStream()
    },
    sendChatMessage: featureOneDependency.sendChatMessage
  )
}

And we have something else in the FeatureTwoWithChat also.

Does this seem like a good pattern?

Is there something else that we could do that would make this work also?

We didn't really want the Chat to have all of the different dependencies in it but still need the ability to use it in both places.

Thanks