http.h

#ifndef SOURCEMETA_CORE_HTTP_H_
#define SOURCEMETA_CORE_HTTP_H_
 
#ifndef SOURCEMETA_CORE_HTTP_EXPORT
#include <sourcemeta/core/http_export.h>
#endif
 
// NOLINTBEGIN(misc-include-cleaner)
#include <sourcemeta/core/http_aws_sigv4.h>
#include <sourcemeta/core/http_error.h>
#include <sourcemeta/core/http_message.h>
#include <sourcemeta/core/http_method.h>
#include <sourcemeta/core/http_problem.h>
#include <sourcemeta/core/http_status.h>
#include <sourcemeta/core/http_syntax.h>
#include <sourcemeta/core/http_system.h>
// NOLINTEND(misc-include-cleaner)
 
#include <chrono>           // std::chrono::system_clock
#include <cstddef>          // std::size_t
#include <cstdint>          // std::uint8_t
#include <initializer_list> // std::initializer_list
#include <optional>         // std::optional
#include <span>             // std::span
#include <string>           // std::string
#include <string_view>      // std::string_view
#include <utility>          // std::pair
#include <vector>           // std::vector

 
namespace sourcemeta::core {

enum class HTTPContentEncoding : std::uint8_t {
  Identity,
  GZIP,
};

SOURCEMETA_CORE_HTTP_EXPORT
auto http_match_accept(const std::string_view accept_header,
                       std::initializer_list<std::string_view> candidates)
    -> std::string_view;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_accept_includes_all(
    const std::string_view accept_header,
    std::initializer_list<std::string_view> media_types) noexcept -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_content_type_matches(const std::string_view content_type_header,
                               const std::string_view media_type) noexcept
    -> bool;

struct HTTPMediaType {
  std::string_view type{};
  std::string_view subtype{};
  std::string_view suffix{};
  std::string_view parameters{};
};

SOURCEMETA_CORE_HTTP_EXPORT
auto http_parse_media_type(const std::string_view media_type)
    -> std::optional<HTTPMediaType>;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_match_media_range(const std::string_view media_type,
                            std::span<const std::string_view> ranges) noexcept
    -> std::string_view;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_match_accept_language(
    const std::string_view accept_language_header,
    std::initializer_list<std::string_view> candidates) -> std::string_view;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_negotiate_encoding(
    const std::string_view accept_encoding_header,
    const HTTPContentEncoding server_preference) noexcept
    -> std::optional<HTTPContentEncoding>;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_from_date(const std::string_view value) noexcept
    -> std::optional<std::chrono::system_clock::time_point>;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_cache_control_max_age(const std::string_view cache_control) noexcept
    -> std::optional<std::chrono::seconds>;

struct HTTPLink {
  std::string_view target;
  std::string_view rel;
  std::span<const std::pair<std::string_view, std::string_view>> parameters{};
};

SOURCEMETA_CORE_HTTP_EXPORT
auto http_format_link(const HTTPLink &link, std::string &out) -> void;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_format_link(const HTTPLink &link) -> std::string;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_format_links(std::span<const HTTPLink> links, std::string &out)
    -> void;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_format_links(std::span<const HTTPLink> links) -> std::string;

enum class HTTPCacheVisibility : std::uint8_t {
  Public,
  Private
};

struct HTTPCacheControl {
  std::optional<HTTPCacheVisibility> visibility{};
  std::optional<std::chrono::seconds> max_age{};
  std::optional<std::chrono::seconds> shared_max_age{};
  bool no_store{false};
  bool no_cache{false};
  bool must_revalidate{false};
  bool proxy_revalidate{false};
  bool must_understand{false};
  bool no_transform{false};
  bool immutable{false};
  std::span<const std::string_view> private_fields{};
  std::span<const std::string_view> no_cache_fields{};
};

SOURCEMETA_CORE_HTTP_EXPORT
auto http_cache_control_valid(const HTTPCacheControl &directives) -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_serialize_cache_control(const HTTPCacheControl &directives,
                                  std::string &out) -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_serialize_cache_control(const HTTPCacheControl &directives)
    -> std::optional<std::string>;

struct HTTPChallenge {
  std::string_view scheme{};
  std::optional<std::string_view> token68{};
  std::span<const std::pair<std::string_view, std::string_view>> parameters{};
};

SOURCEMETA_CORE_HTTP_EXPORT
auto http_challenge_valid(const HTTPChallenge &challenge) -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_serialize_challenge(const HTTPChallenge &challenge, std::string &out)
    -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_serialize_challenge(const HTTPChallenge &challenge)
    -> std::optional<std::string>;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_serialize_challenges(std::span<const HTTPChallenge> challenges,
                               std::string &out) -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_serialize_challenges(std::span<const HTTPChallenge> challenges)
    -> std::optional<std::string>;

struct HTTPParsedChallenge {
  std::string scheme;
  std::optional<std::string> token68;
  std::vector<std::pair<std::string, std::string>> parameters;
};

SOURCEMETA_CORE_HTTP_EXPORT
auto http_parse_challenges(const std::string_view input,
                           std::vector<HTTPParsedChallenge> &challenges)
    -> bool;

enum class HTTPCookieSameSite : std::uint8_t {
  Strict,
  Lax,
  None
};

struct HTTPCookie {
  std::string_view name{};
  std::string_view value{};
  std::optional<std::string_view> path{};
  std::optional<std::string_view> domain{};
  std::optional<std::chrono::seconds> max_age{};
  bool http_only{false};
  bool secure{false};
  std::optional<HTTPCookieSameSite> same_site{};
};

inline constexpr std::size_t HTTP_COOKIE_MAXIMUM_NAME_VALUE_LENGTH{4096};

inline constexpr std::size_t HTTP_COOKIE_MAXIMUM_ATTRIBUTE_VALUE_LENGTH{1024};

SOURCEMETA_CORE_HTTP_EXPORT
auto http_cookie_valid(const HTTPCookie &cookie) -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_serialize_cookie(const HTTPCookie &cookie, std::string &out) -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_serialize_cookie(const HTTPCookie &cookie)
    -> std::optional<std::string>;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_expire_cookie(const HTTPCookie &cookie) -> HTTPCookie;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_field_list_contains_any(
    const std::string_view header_value,
    std::initializer_list<std::string_view> tokens) noexcept -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_format_vary(std::span<const std::string_view> field_names,
                      std::string &out) -> bool;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_format_vary(std::span<const std::string_view> field_names)
    -> std::optional<std::string>;

SOURCEMETA_CORE_HTTP_EXPORT
auto http_parse_bearer(const std::string_view authorization) noexcept
    -> std::string_view;
 
} // namespace sourcemeta::core
 
#endif