Subscriptions

import Apollo
import ApolloWebSocket
import Foundation

func makeApolloClient() throws -> ApolloClient {
  let store = ApolloStore()
  let endpointURL = URL(string: "https://api.example.com/graphql")!
  let webSocketURL = URL(string: "wss://api.example.com/graphql")!

  // HTTP transport for queries and mutations.
  let httpTransport = RequestChainNetworkTransport(
    urlSession: URLSession(configuration: .default),
    interceptorProvider: DefaultInterceptorProvider(),
    store: store,
    endpointURL: endpointURL
  )

  // WebSocket transport for subscriptions.
  let webSocketTransport = try WebSocketTransport(
    urlSession: URLSession(configuration: .default),
    store: store,
    endpointURL: webSocketURL,
    configuration: WebSocketTransport.Configuration(
      reconnectionInterval: 1.0,
      connectingPayload: [
        // Sent in the `connection_init` message. See "Auth" below.
        "Authorization": "Bearer \(currentAuthToken())"
      ],
      pingInterval: 20.0
    )
  )

  let splitTransport = SplitNetworkTransport(
    queryTransport: httpTransport,
    mutationTransport: httpTransport,
    subscriptionTransport: webSocketTransport,
    uploadTransport: httpTransport
  )

  return ApolloClient(networkTransport: splitTransport, store: store)
}

WebSocketTransport.Configuration(
  connectingPayload: [
    "Authorization": "Bearer \(token)"
  ]
)

await webSocketTransport.updateConnectingPayload([
  "Authorization": "Bearer \(newToken)"
])

import SwiftUI

struct RootView: View {
  @Environment(\.apolloClient) private var apolloClient
  @Environment(\.scenePhase) private var scenePhase
  let webSocketTransport: WebSocketTransport

  var body: some View {
    ContentView()
      .onChange(of: scenePhase) { _, newPhase in
        Task {
          switch newPhase {
          case .background, .inactive:
            await webSocketTransport.pause()
          case .active:
            await webSocketTransport.resume()
          @unknown default:
            break
          }
        }
      }
  }
}

import SwiftUI
import Apollo

@Observable
@MainActor
final class MessageViewModel {
  var messages: [MessageReceivedSubscription.Data.MessageReceived] = []

  private let apolloClient: ApolloClient

  init(apolloClient: ApolloClient) { self.apolloClient = apolloClient }

  func listen() async {
    do {
      let stream = try apolloClient.subscribe(
        subscription: MessageReceivedSubscription(),
        cachePolicy: .cacheThenNetwork
      )
      for try await response in stream {
        if let newMessage = response.data?.messageReceived {
          messages.append(newMessage)
        }
      }
    } catch is CancellationError {
      // Expected when the view goes away.
    } catch {
      print("Subscription failed: \(error)")
    }
  }
}

struct ChatView: View {
  @Environment(\.apolloClient) private var apolloClient
  @State private var viewModel: MessageViewModel?

  var body: some View {
    Group {
      if let viewModel {
        List(viewModel.messages, id: \.id) { message in
          Text(message.body)
        }
        .task { await viewModel.listen() }
      }
    }
    .onAppear {
      if viewModel == nil {
        viewModel = MessageViewModel(apolloClient: apolloClient)
      }
    }
  }
}