http_error.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "http_types.h"
#include <string>
#include <string_view>
#include <chrono>
 
namespace kcenon::network::internal
{
 
    enum class http_error_code
    {
        // Client Errors (4xx)
        bad_request = 400,
        unauthorized = 401,
        payment_required = 402,
        forbidden = 403,
        not_found = 404,
        method_not_allowed = 405,
        not_acceptable = 406,
        proxy_authentication_required = 407,
        request_timeout = 408,
        conflict = 409,
        gone = 410,
        length_required = 411,
        precondition_failed = 412,
        payload_too_large = 413,
        uri_too_long = 414,
        unsupported_media_type = 415,
        range_not_satisfiable = 416,
        expectation_failed = 417,
        im_a_teapot = 418,
        misdirected_request = 421,
        unprocessable_entity = 422,
        locked = 423,
        failed_dependency = 424,
        too_early = 425,
        upgrade_required = 426,
        precondition_required = 428,
        too_many_requests = 429,
        request_header_fields_too_large = 431,
        unavailable_for_legal_reasons = 451,
 
        // Server Errors (5xx)
        internal_server_error = 500,
        not_implemented = 501,
        bad_gateway = 502,
        service_unavailable = 503,
        gateway_timeout = 504,
        http_version_not_supported = 505,
        variant_also_negotiates = 506,
        insufficient_storage = 507,
        loop_detected = 508,
        not_extended = 510,
        network_authentication_required = 511
    };
 
    struct http_error
    {
        http_error_code code = http_error_code::internal_server_error;
        std::string message;
        std::string detail;
        std::string request_id;
        std::chrono::system_clock::time_point timestamp = std::chrono::system_clock::now();
 
        auto status_code() const -> int { return static_cast<int>(code); }
 
        auto is_client_error() const -> bool
        {
            int status = status_code();
            return status >= 400 && status < 500;
        }
 
        auto is_server_error() const -> bool
        {
            int status = status_code();
            return status >= 500 && status < 600;
        }
    };
 
    enum class parse_error_type
    {
        invalid_method,
        invalid_uri,
        invalid_version,
        invalid_header,
        incomplete_headers,
        incomplete_body,
        body_too_large,
        header_too_large,
        malformed_request
    };
 
    struct parse_error
    {
        parse_error_type error_type = parse_error_type::malformed_request;
        size_t line_number = 0;
        size_t column_number = 0;
        std::string context;
        std::string message;
 
        auto to_http_error() const -> http_error
        {
            http_error err;
            err.code = http_error_code::bad_request;
            err.message = "Bad Request";
            err.detail = message;
            if (!context.empty())
            {
                err.detail += " near: " + context;
            }
            return err;
        }
    };
 
    auto get_error_status_text(http_error_code code) -> std::string_view;
 
    class http_error_response
    {
    public:
        static auto build_json_error(const http_error& error) -> http_response;
 
        static auto build_html_error(const http_error& error) -> http_response;
 
        static auto make_error(http_error_code code, const std::string& detail = "",
                               const std::string& request_id = "") -> http_error;
    };
 
} // namespace kcenon::network::internal