http_client_interface.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
#include <kcenon/common/patterns/result.h>
 
namespace kcenon::common {
namespace interfaces {
 
using http_headers = std::map<std::string, std::string>;
 
struct http_request {
    std::string url;
 
    std::string method = "GET";
 
    http_headers headers;
 
    std::vector<uint8_t> body;
 
    std::chrono::milliseconds timeout{30000};
 
    bool follow_redirects = true;
 
    int max_redirects = 5;
 
    // Convenience constructors
 
    http_request() = default;
 
    explicit http_request(std::string url_)
        : url(std::move(url_)) {}
 
    http_request(std::string url_, std::string method_)
        : url(std::move(url_)), method(std::move(method_)) {}
 
    http_request(std::string url_, std::string method_, http_headers headers_)
        : url(std::move(url_))
        , method(std::move(method_))
        , headers(std::move(headers_)) {}
 
    http_request(std::string url_,
                 std::string method_,
                 http_headers headers_,
                 std::vector<uint8_t> body_)
        : url(std::move(url_))
        , method(std::move(method_))
        , headers(std::move(headers_))
        , body(std::move(body_)) {}
 
    http_request& set_content_type(const std::string& content_type) {
        headers["Content-Type"] = content_type;
        return *this;
    }
 
    http_request& set_authorization(const std::string& auth) {
        headers["Authorization"] = auth;
        return *this;
    }
 
    http_request& set_body(const std::string& str) {
        body.assign(str.begin(), str.end());
        return *this;
    }
};
 
struct http_response {
    int status_code = 0;
 
    std::string reason_phrase;
 
    http_headers headers;
 
    std::vector<uint8_t> body;
 
    std::chrono::milliseconds elapsed{0};
 
    std::optional<std::string> final_url;
 
    // Convenience methods
 
    [[nodiscard]] bool is_success() const {
        return status_code >= 200 && status_code < 300;
    }
 
    [[nodiscard]] bool is_client_error() const {
        return status_code >= 400 && status_code < 500;
    }
 
    [[nodiscard]] bool is_server_error() const {
        return status_code >= 500 && status_code < 600;
    }
 
    [[nodiscard]] std::string body_as_string() const {
        return std::string(body.begin(), body.end());
    }
 
    [[nodiscard]] std::optional<std::string> get_header(
        const std::string& name) const {
        auto it = headers.find(name);
        if (it != headers.end()) {
            return it->second;
        }
        return std::nullopt;
    }
};
 
class IHttpClient {
public:
    virtual ~IHttpClient() = default;
 
    virtual ::kcenon::common::Result<http_response> send(const http_request& request) = 0;
 
    [[nodiscard]] virtual bool is_available() const = 0;
 
    [[nodiscard]] virtual std::string get_implementation_name() const {
        return "IHttpClient";
    }
};
 
class null_http_client : public IHttpClient {
public:
    ::kcenon::common::Result<http_response> send(const http_request& /*request*/) override {
        return ::kcenon::common::make_error<http_response>(
            ::kcenon::common::error_codes::NOT_INITIALIZED,
            "HTTP client not available",
            "null_http_client");
    }
 
    [[nodiscard]] bool is_available() const override {
        return false;
    }
 
    [[nodiscard]] std::string get_implementation_name() const override {
        return "null_http_client";
    }
};
 
using HttpClientFactory = std::function<std::shared_ptr<IHttpClient>()>;
 
class IHttpClientProvider {
public:
    virtual ~IHttpClientProvider() = default;
 
    virtual std::shared_ptr<IHttpClient> get_http_client() = 0;
 
    virtual std::shared_ptr<IHttpClient> create_http_client(
        std::chrono::milliseconds timeout = std::chrono::milliseconds{30000}) = 0;
};
 
}  // namespace interfaces
}  // namespace kcenon::common