Checkers.hpp

#pragma once
 
#include "rpc/Errors.hpp"
#include "rpc/common/ValidationHelpers.hpp"
 
#include <boost/json/value.hpp>
#include <boost/json/value_to.hpp>
#include <fmt/format.h>
 
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace rpc::check {
struct Warning {
    Warning(WarningCode code, std::string message)
        : warningCode(code), extraMessage(std::move(message))
    {
    }
 
    bool
    operator==(Warning const& other) const = default;
 
    WarningCode warningCode;
    std::string extraMessage;
};
using Warnings = std::vector<Warning>;

template <typename... T>
class Deprecated;

template <>
class Deprecated<> final {
public:
    [[nodiscard]] static std::optional<Warning>
    check(boost::json::value const& value, std::string_view key)
    {
        if (value.is_object() and value.as_object().contains(key)) {
            return Warning{
                WarningCode::WarnRpcDeprecated, fmt::format("Field '{}' is deprecated.", key)
            };
        }
        return std::nullopt;
    }
};

template <typename T>
class Deprecated<T> final {
    T value_;
 
public:
    Deprecated(T val) : value_(std::move(val))
    {
    }

    [[nodiscard]] std::optional<Warning>
    check(boost::json::value const& value, std::string_view key) const
    {
        if (value.is_object() and value.as_object().contains(key) and
            validation::checkType<T>(value.as_object().at(key))) {
            using boost::json::value_to;
            auto const res = value_to<T>(value.as_object().at(key));
            if (value_ == res) {
                return Warning{
                    WarningCode::WarnRpcDeprecated,
                    fmt::format("Value '{}' for field '{}' is deprecated", value_, key)
                };
            }
        }
        return std::nullopt;
    }
};

template <typename... T>
Deprecated(T&&...) -> Deprecated<T...>;
 
}  // namespace rpc::check