Skip to content
The Chat Archive
claude-3-5-sonnet-20241022· Anthropic LMArena Human Preference 140K

Create a generic GET and POST Request struct in Swift

  1. User

    Create a generic GET and POST Request struct in Swift

  2. Assistant

    Here's a simple implementation of generic GET and POST request structs in Swift:

    struct HTTPRequest<T: Codable> {
        let baseURL: String
        let endpoint: String
        let method: HTTPMethod
        let headers: [String: String]?
        let queryParams: [String: String]?
        let body: T?
        
        enum HTTPMethod: String {
            case get = "GET"
            case post = "POST"
        }
        
        init(baseURL: String,
             endpoint: String,
             method: HTTPMethod,
             headers: [String: String]? = nil,
             queryParams: [String: String]? = nil,
             body: T? = nil) {
            self.baseURL = baseURL
            self.endpoint = endpoint
            self.method = method
            self.headers = headers
            self.queryParams = queryParams
            self.body = body
        }
        
        func buildURLRequest() throws -> URLRequest {
            var urlComponents = URLComponents(string: baseURL + endpoint)
            
            if let queryParams = queryParams {
                urlComponents?.queryItems = queryParams.map { 
                    URLQueryItem(name: $0.key, value: $0.value)
                }
            }
            
            guard let url = urlComponents?.url else {
                throw URLError(.badURL)
            }
            
            var request = URLRequest(url: url)
            request.httpMethod = method.rawValue
            
            if let headers = headers {
                headers.forEach { request.addValue($0.value, forHTTPHeaderField: $0.key) }
            }
            
            if let body = body {
                let encoder = JSONEncoder()
                request.httpBody = try encoder.encode(body)
                request.addValue("application/json", forHTTPHeaderField: "Content-Type")
            }
            
            return request
        }
    }
    

    Usage example:

    // GET Request
    struct UserResponse: Codable {
        let id: Int
        let name: String
    }
    
    let getRequest = HTTPRequest<UserResponse>(
        baseURL: "https://api.example.com",
        endpoint: "/users",
        method: .get,
        headers: ["Authorization": "Bearer token"],
        queryParams: ["page": "1"]
    )
    
    // POST Request
    struct CreateUser: Codable {
        let name: String
        let email: String
    }
    
    let postRequest = HTTPRequest<CreateUser>(
        baseURL: "https://api.example.com",
        endpoint: "/users",
        method: .post,
        headers: ["Authorization": "Bearer token"],
        body: CreateUser(name: "John Doe", email: "john@example.com")
    )
    
    // Making the request
    do {
        let urlRequest = try postRequest.buildURLRequest()
        // Use URLSession to make the network call
    } catch {
        print("Error creating request: \(error)")
    }
    

    This implementation provides:

    • Generic type support for request body
    • URL query parameters
    • Custom headers
    • Error handling
    • Support for both GET and POST methods
    • URL composition with base URL and endpoint
    • JSON encoding for request body

    Would you like me to explain any particular part in more detail?

  3. User

    expand the struct to allow for PUT and DELETE

  4. Assistant

    Here's the expanded version of the HTTPRequest struct that includes PUT and DELETE methods:

    struct HTTPRequest<T: Codable> {
        let baseURL: String
        let endpoint: String
        let method: HTTPMethod
        let headers: [String: String]?
        let queryParams: [String: String]?
        let body: T?
        
        enum HTTPMethod: String {
            case get = "GET"
            case post = "POST"
            case put = "PUT"
            case delete = "DELETE"
            
            var requiresBody: Bool {
                switch self {
                case .post, .put:
                    return true
                case .get, .delete:
                    return false
                }
            }
        }
        
        init(baseURL: String,
             endpoint: String,
             method: HTTPMethod,
             headers: [String: String]? = nil,
             queryParams: [String: String]? = nil,
             body: T? = nil) {
            self.baseURL = baseURL
            self.endpoint = endpoint
            self.method = method
            self.headers = headers
            self.queryParams = queryParams
            self.body = body
        }
        
        func buildURLRequest() throws -> URLRequest {
            var urlComponents = URLComponents(string: baseURL + endpoint)
            
            if let queryParams = queryParams {
                urlComponents?.queryItems = queryParams.map { 
                    URLQueryItem(name: $0.key, value: $0.value)
                }
            }
            
            guard let url = urlComponents?.url else {
                throw RequestError.invalidURL
            }
            
            var request = URLRequest(url: url)
            request.httpMethod = method.rawValue
            
            // Add default headers
            request.addValue("application/json", forHTTPHeaderField: "Content-Type")
            request.addValue("application/json", forHTTPHeaderField: "Accept")
            
            // Add custom headers
            if let headers = headers {
                headers.forEach { request.addValue($0.value, forHTTPHeaderField: $0.key) }
            }
            
            // Handle body for POST and PUT requests
            if method.requiresBody {
                guard let body = body else {
                    throw RequestError.missingBody
                }
                let encoder = JSONEncoder()
                request.httpBody = try encoder.encode(body)
            }
            
            return request
        }
    }
    
    // Custom error enum for better error handling
    enum RequestError: Error {
        case invalidURL
        case missingBody
        case invalidResponse
        case encodingError
        
        var localizedDescription: String {
            switch self {
            case .invalidURL:
                return "The URL is invalid"
            case .missingBody:
                return "Request body is required for this method"
            case .invalidResponse:
                return "Invalid response from server"
            case .encodingError:
                return "Failed to encode request body"
            }
        }
    }
    

    Usage examples:

    // Example models
    struct User: Codable {
        let id: Int
        let name: String
        let email: String
    }
    
    struct UpdateUser: Codable {
        let name: String
        let email: String
    }
    
    // GET Request
    let getRequest = HTTPRequest<User>(
        baseURL: "https://api.example.com",
        endpoint: "/users/1",
        method: .get
    )
    
    // POST Request
    let createUser = UpdateUser(name: "John Doe", email: "john@example.com")
    let postRequest = HTTPRequest<UpdateUser>(
        baseURL: "https://api.example.com",
        endpoint: "/users",
        method: .post,
        headers: ["Authorization": "Bearer token"],
        body: createUser
    )
    
    // PUT Request
    let updateUser = UpdateUser(name: "John Updated", email: "john.updated@example.com")
    let putRequest = HTTPRequest<UpdateUser>(
        baseURL: "https://api.example.com",
        endpoint: "/users/1",
        method: .put,
        headers: ["Authorization": "Bearer token"],
        body: updateUser
    )
    
    // DELETE Request
    let deleteRequest = HTTPRequest<User>(
        baseURL: "https://api.example.com",
        endpoint: "/users/1",
        method: .delete,
        headers: ["Authorization": "Bearer token"]
    )
    
    // Example of making a request
    func makeRequest<T: Codable>(_ request: HTTPRequest<T>) async throws -> T {
        let urlRequest = try request.buildURLRequest()
        
        let (data, response) = try await URLSession.shared.data(for: urlRequest)
        
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw RequestError.invalidResponse
        }
        
        let decoder = JSONDecoder()
        return try decoder.decode(T.self, from: data)
    }
    
    // Using the request
    Task {
        do {
            let user = try await makeRequest(getRequest)
            print("Received user: \(user)")
        } catch {
            print("Error: \(error.localizedDescription)")
        }
    }
    

    Key improvements in this version:

    • Added PUT and DELETE methods
    • Added requiresBody property to HTTPMethod to enforce body requirements
    • Enhanced error handling with custom RequestError enum
    • Added default headers for Content-Type and Accept
    • Included an example async/await network call implementation
    • Added validation for required bodies in POST and PUT requests

    Would you like me to explain any specific part of the implementation?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.