Operations

# GetUserQuery.graphql
query GetUser($id: ID!) {
  user(id: $id) {
    id
    name
    email
  }
}

./apollo-ios-cli generate

import Apollo

func loadUser(id: String) async throws -> GetUserQuery.Data.User? {
  let response = try await apolloClient.fetch(
    query: GetUserQuery(id: id),
    cachePolicy: .cacheFirst
  )
  if let firstError = response.errors?.first {
    // `GraphQLError` conforms to `Error`, so it can be thrown directly.
    // Inspect `response.errors` for all of them if you need the full list.
    throw firstError
  }
  return response.data?.user
}

func streamUser(id: String) throws -> AsyncThrowingStream<GraphQLResponse<GetUserQuery>, any Error> {
  try apolloClient.fetch(query: GetUserQuery(id: id), cachePolicy: .cacheAndNetwork)
}

let cached = try await apolloClient.fetch(query: GetUserQuery(id: id), cachePolicy: .cacheOnly)

func updateUserName(id: String, name: String) async throws {
  let response = try await apolloClient.perform(
    mutation: UpdateUserNameMutation(id: id, name: name)
  )
  if let firstError = response.errors?.first {
    throw firstError
  }
}

public typealias ResultHandler = @Sendable (Result<GraphQLResponse<Query>, any Swift.Error>) -> Void

import Apollo

@Observable
@MainActor
final class UserViewModel {
  var user: GetUserQuery.Data.User?
  var errorMessage: String?

  private let apolloClient: ApolloClient
  private var watcher: GraphQLQueryWatcher<GetUserQuery>?

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

  func start(userID: String) async {
    cancel()
    watcher = await apolloClient.watch(
      query: GetUserQuery(id: userID),
      cachePolicy: .cacheFirst
    ) { [weak self] result in
      Task { @MainActor in
        guard let self else { return }
        switch result {
        case .success(let response):
          self.user = response.data?.user
          self.errorMessage = response.errors?.first?.message
        case .failure(let error):
          self.errorMessage = error.localizedDescription
        }
      }
    }
  }

  func cancel() {
    watcher?.cancel()
    watcher = nil
  }

  deinit { watcher?.cancel() }
}

struct UserDetailView: View {
  let userID: String
  @State private var viewModel: UserViewModel

  init(userID: String, apolloClient: ApolloClient) {
    self.userID = userID
    _viewModel = State(initialValue: UserViewModel(apolloClient: apolloClient))
  }

  var body: some View {
    Group {
      if let user = viewModel.user {
        Text(user.name)
      } else if let message = viewModel.errorMessage {
        Text(message).foregroundStyle(.red)
      } else {
        ProgressView()
      }
    }
    .task(id: userID) {
      await viewModel.start(userID: userID)
    }
    .onDisappear {
      viewModel.cancel()
    }
  }
}

let response = try await apolloClient.fetch(query: GetUserQuery(id: id))

// `response.errors` is `[GraphQLError]?`. Each `GraphQLError` conforms to
// `Error` and carries `.message`, `.locations`, `.path`, and `.extensions`.
// `response.data` may still contain partial data when there are errors.
if let firstError = response.errors?.first {
  throw firstError
}

guard let user = response.data?.user else {
  // No user was returned but no errors either — treat as not found.
  throw UserNotFound()
}

enum APIError: Error {
  case graphQL([GraphQLError])
}

if let errors = response.errors, !errors.isEmpty {
  throw APIError.graphQL(errors)
}