feat: Add LightWeight GraphQL Client (#12)

feat: Add LightWeight GraphQL Client

- It uses query strings and filename to specify query.
- Encodable structures to pass variables

Author: abelonogov-ld

.gitignore

@@ -6,3 +6,4 @@ DerivedData/
 .swiftpm/configuration/registries.json
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 .netrc
+**/Package.resolved

Package.swift

@@ -23,6 +23,13 @@ let package = Package(
                 .product(name: "ResourceExtension", package: "opentelemetry-swift"),
             ]
         ),
+        .testTarget(
+            name: "CommonTests",
+            dependencies: [
+                "Common"
+            ],
+            resources: [.process("GraphQL/Queries")]
+        ),
         .target(name: "CrashReporter"),
         .target(
             name: "CrashReporterLive",

Sources/Common/AtomicDictionary.swift

@@ -20,6 +20,6 @@ where Key: Hashable, Key: Sendable {
   }
 
   public var debugDescription: String {
-    return storage.debugDescription
+      return queue.sync { storage.debugDescription }
   }
 }

Sources/Common/GraphQL/GraphQLClient.swift

@@ -0,0 +1,162 @@
+import Foundation
+
+public final class GraphQLClient {
+    private let endpoint: URL
+    private let network: NetworkClient
+    private let decoder: JSONDecoder
+    private let defaultHeaders: [String: String]
+
+    public init(endpoint: URL,
+                network: NetworkClient = URLSessionNetworkClient(),
+                decoder: JSONDecoder = JSONDecoder(),
+                defaultHeaders: [String: String] = [
+                    "Content-Type": "application/json",
+                    "Accept": "application/json"
+                ]) {
+        self.endpoint = endpoint
+        self.network = network
+        self.decoder = decoder
+        self.defaultHeaders = defaultHeaders
+    }
+
+    /// Execute a GraphQL operation from stirng query
+    /// - Parameters:
+    ///   - query: Query in graphql format
+    ///   - variables: Codable variables (optional)
+    ///   - operationName: Operation name (optional)
+    ///   - headers: Extra headers (merged over defaultHeaders)
+    public func execute<Variables: Encodable, Output: Decodable>(
+        query: String,
+        variables: Variables? = nil,
+        operationName: String? = nil,
+        headers: [String: String] = [:]
+    ) async throws -> Output {
+        let gqlRequest = GraphQLRequest(query: query, variables: variables, operationName: operationName)
+        var request = URLRequest(url: endpoint)
+        request.httpMethod = "POST"
+        request.httpBody = try gqlRequest.httpBody()
+
+        let combinedHeaders = defaultHeaders.merging(headers) { _, new in new }
+        combinedHeaders.forEach { request.setValue($0.value, forHTTPHeaderField: $0.key) }
+
+        let data = try await network.send(request)
+
+        do {
+            let envelope = try decoder.decode(GraphQLResponse<Output>.self, from: data)
+            if let errors = envelope.errors, !errors.isEmpty {
+                throw GraphQLClientError.graphQLErrors(errors)
+            }
+            guard let value = envelope.data else {
+                throw GraphQLClientError.missingData
+            }
+            return value
+        } catch {
+            throw GraphQLClientError.decoding(error)
+        }
+    }
+    
+    /// Execute a GraphQL operation where the query is loaded from a .graphql file in a bundle.
+    /// - Parameters:
+    ///   - resource: Filename without extension (e.g., "GetUser")
+    ///   - ext: File extension (defaults to "graphql")
+    ///   - bundle: Bundle to search (defaults to .main)
+    ///   - variables: Codable variables (optional)
+    ///   - operationName: Operation name (optional)
+    ///   - headers: Extra headers (merged over defaultHeaders)
+    public func executeFromFile<Variables: Encodable, Output: Decodable>(
+        resource: String,
+        ext: String = "graphql",
+        bundle: Bundle = Bundle.main,
+        variables: Variables? = nil,
+        operationName: String? = nil,
+        headers: [String: String] = [:]
+    ) async throws -> Output {
+        guard let url = bundle.url(forResource: resource, withExtension: ext) else {
+            throw GraphQLClientError.queryFileNotFound("\(resource).\(ext)")
+        }
+
+        let query: String
+        do {
+            query = try String(contentsOf: url, encoding: .utf8)
+        } catch {
+            throw GraphQLClientError.unreadableQueryFile(url, error)
+        }
+
+        return try await execute(
+            query: query,
+            variables: variables,
+            operationName: operationName,
+            headers: headers
+        )
+    }
+}
+
+/// Standard GraphQL envelope: { data, errors }
+private struct GraphQLResponse<DataType: Decodable>: Decodable {
+    let data: DataType?
+    let errors: [GraphQLError]?
+}
+
+public enum GraphQLClientError: Error, CustomStringConvertible {
+    case graphQLErrors([GraphQLError])
+    case missingData
+    case decoding(Error)
+    case queryFileNotFound(String)
+    case unreadableQueryFile(URL, Error?)
+
+    public var description: String {
+        switch self {
+        case .graphQLErrors(let errors):
+            return "GraphQL errors: \(errors.map(\.message).joined(separator: " | "))"
+        case .missingData:
+            return "Missing `data` in GraphQL response"
+        case .decoding(let error):
+            return "Decoding error: \(error)"
+        case .queryFileNotFound(let name):
+            return "GraphQL file '\(name)' not found in bundle"
+        case .unreadableQueryFile(let url, let err):
+            return "Could not read GraphQL file at \(url). \(err?.localizedDescription ?? "")"
+        }
+    }
+}
+
+public struct GraphQLError: Decodable {
+    public let message: String
+}
+
+public struct GraphQLEmptyData: Decodable {}
+
+extension GraphQLClient {
+    public func executeIgnoringData<Variables: Encodable>(
+        query: String,
+        variables: Variables? = nil,
+        operationName: String? = nil,
+        headers: [String: String] = [:]
+    ) async throws {
+        // Reuse EmptyData so decoding still works with `{ "data": null }` or `{ "data": {} }`
+        _ = try await execute(
+            query: query,
+            variables: variables,
+            operationName: operationName,
+            headers: headers
+        ) as GraphQLEmptyData
+    }
+
+    public func executeFromFileIgnoringData<Variables: Encodable>(
+        resource: String,
+        ext: String = "graphql",
+        bundle: Bundle = .main,
+        variables: Variables? = nil,
+        operationName: String? = nil,
+        headers: [String: String] = [:]
+    ) async throws {
+        _ = try await executeFromFile(
+            resource: resource,
+            ext: ext,
+            bundle: bundle,
+            variables: variables,
+            operationName: operationName,
+            headers: headers
+        ) as GraphQLEmptyData
+    }
+}

Sources/Common/GraphQL/GraphQLRequest.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+/// Encodes the GraphQL POST body: { query, variables, operationName }
+public struct GraphQLRequest<Variables: Encodable>: Encodable {
+    public let query: String
+    public let variables: Variables?
+    public let operationName: String?
+
+    public init(query: String,
+                variables: Variables? = nil,
+                operationName: String? = nil) {
+        self.query = query
+        self.variables = variables
+        self.operationName = operationName
+    }
+
+    /// Create the HTTP body data for this request.
+    /// You can reuse this anywhere you need to build a GraphQL body.
+    public func httpBody(encoder: JSONEncoder = JSONEncoder()) throws -> Data {
+        try encoder.encode(self)
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case query
+        case variables
+        case operationName
+    }
+}

Sources/Common/Network/NetworkClient.swift

@@ -0,0 +1,42 @@
+import Foundation
+
+public enum NetworkError: Error, CustomStringConvertible {
+    case invalidResponse
+    case httpStatus(Int, data: Data?)
+    case transport(Error)
+
+    public var description: String {
+        switch self {
+        case .invalidResponse: return "Invalid response type"
+        case .httpStatus(let code, _): return "HTTP status \(code)"
+        case .transport(let error): return "Transport error: \(error)"
+        }
+    }
+}
+
+public protocol NetworkClient {
+    func send(_ request: URLRequest) async throws -> Data
+}
+
+public final class URLSessionNetworkClient: NetworkClient {
+    private let session: URLSession
+
+    public init(session: URLSession = .shared) {
+        self.session = session
+    }
+
+    public func send(_ request: URLRequest) async throws -> Data {
+        do {
+            let (data, response) = try await session.data(for: request)
+            guard let http = response as? HTTPURLResponse else {
+                throw NetworkError.invalidResponse
+            }
+            guard (200...299).contains(http.statusCode) else {
+                throw NetworkError.httpStatus(http.statusCode, data: data)
+            }
+            return data
+        } catch {
+            throw NetworkError.transport(error)
+        }
+    }
+}