http.hpp

 
//
// Copyright 2024 Realm Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
 
#ifndef CPPREALM_NETWORKING_HTTP_HPP
#define CPPREALM_NETWORKING_HTTP_HPP
 
#include <cpprealm/internal/bridge/realm.hpp>
 
#ifndef REALMCXX_VERSION_MAJOR
#include <cpprealm/version_numbers.hpp>
#endif
 
#include <optional>
#include <map>
#include <string>
 
namespace realm::networking {
 
    enum class http_method { get, post, patch, put, del };
    using http_headers = std::map<std::string, std::string>;
 
    struct request {
        http_method method = http_method::get;
 
        std::string url;
 
        uint64_t timeout_ms = 0;
 
        http_headers headers;
 
        std::string body;
    };
 
    struct response {
        int http_status_code;
 
        int custom_status_code;
 
        http_headers headers;
 
        std::string body;
 
        std::optional<std::int32_t> client_error_code;
 
    };
 
    // Interface for providing http transport
    struct http_transport_client {
        virtual ~http_transport_client() = default;
        virtual void send_request_to_server(const request& request,
                                            std::function<void(const response&)>&& completion) = 0;
    };
 
    std::shared_ptr<http_transport_client> make_http_client();
    [[maybe_unused]] void set_http_client_factory(std::function<std::shared_ptr<http_transport_client>()>&&);
 
    struct default_http_transport : public http_transport_client {
        struct configuration {
            std::optional<std::map<std::string, std::string>> custom_http_headers;
            std::optional<::realm::internal::bridge::realm::sync_config::proxy_config> proxy_config;
 
            using SSLVerifyCallback = bool(const std::string& server_address,
                                           internal::bridge::realm::sync_config::proxy_config::port_type server_port,
                                           const char* pem_data, size_t pem_size, int preverify_ok, int depth);
            bool client_validate_ssl = true;
            std::optional<std::string> ssl_trust_certificate_path;
            std::function<SSLVerifyCallback> ssl_verify_callback;
        };
 
        default_http_transport() = default;
        default_http_transport(const configuration& c) : m_configuration(c) {}
 
        ~default_http_transport() = default;
 
        void send_request_to_server(const ::realm::networking::request& request,
                                    std::function<void(const ::realm::networking::response&)>&& completion);
 
    protected:
        configuration m_configuration;
    };
}
 
#endif //CPPREALM_NETWORKING_HTTP_HPP