REST API vs GraphQL Comparison

// Swift - REST API client
import Foundation

enum HTTPMethod: String {
    case GET, POST, PUT, DELETE, PATCH
}

struct APIClient {
    private let baseURL = URL(string: "https://api.example.com")!
    private let session: URLSession

    init(session: URLSession = .shared) {
        self.session = session
    }

    func request<T: Decodable>(
        path: String,
        method: HTTPMethod = .GET,
        body: Encodable? = nil
    ) async throws -> T {
        var url = baseURL.appendingPathComponent(path)
        var request = URLRequest(url: url)
        request.httpMethod = method.rawValue
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue("Bearer \\(AuthManager.shared.token)", forHTTPHeaderField: "Authorization")

        if let body {
            request.httpBody = try JSONEncoder().encode(body)
        }

        let (data, response) = try await session.data(for: request)

        guard let http = response as? HTTPURLResponse else {
            throw APIError.invalidResponse
        }

        switch http.statusCode {
        case 200...299:
            return try JSONDecoder().decode(T.self, from: data)
        case 401:
            throw APIError.unauthorized
        case 404:
            throw APIError.notFound
        default:
            throw APIError.serverError(http.statusCode)
        }
    }
}

// Usage
let client = APIClient()
let user: User = try await client.request(path: "/users/123")
let posts: [Post] = try await client.request(path: "/users/123/posts")

// Swift - GraphQL Apollo client
import Apollo
import Foundation

// GraphQL query definition (code-generated)
// query GetUserWithPosts($id: ID!) {
//   user(id: $id) {
//     id
//     name
//     email
//     posts(limit: 5) {
//       id
//       title
//       excerpt
//       publishedAt
//     }
//   }
// }

class GraphQLService {
    private lazy var apollo = ApolloClient(url: URL(string: "https://api.example.com/graphql")!)

    func fetchUserWithPosts(id: String) async throws -> UserWithPostsQuery.Data.User {
        try await withCheckedThrowingContinuation { continuation in
            apollo.fetch(query: UserWithPostsQuery(id: id)) { result in
                switch result {
                case .success(let graphQLResult):
                    if let errors = graphQLResult.errors {
                        continuation.resume(throwing: GraphQLError(errors))
                    } else if let user = graphQLResult.data?.user {
                        continuation.resume(returning: user)
                    } else {
                        continuation.resume(throwing: APIError.notFound)
                    }
                case .failure(let error):
                    continuation.resume(throwing: error)
                }
            }
        }
    }

    func createPost(title: String, content: String) async throws -> CreatePostMutation.Data.CreatePost {
        try await withCheckedThrowingContinuation { continuation in
            apollo.perform(mutation: CreatePostMutation(title: title, content: content)) { result in
                switch result {
                case .success(let graphQLResult):
                    if let post = graphQLResult.data?.createPost {
                        continuation.resume(returning: post)
                    } else {
                        continuation.resume(throwing: APIError.invalidResponse)
                    }
                case .failure(let error):
                    continuation.resume(throwing: error)
                }
            }
        }
    }
}