MetaProcessors.hpp

#pragma once
 
#include "rpc/Errors.hpp"
#include "rpc/common/Concepts.hpp"
#include "rpc/common/Specs.hpp"
#include "rpc/common/Types.hpp"
 
#include <boost/json/value.hpp>
#include <fmt/format.h>
 
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <optional>
#include <string_view>
#include <utility>
#include <vector>
 
namespace rpc::meta {

class Section final {
    std::vector<FieldSpec> specs_;
 
public:
    explicit Section(std::initializer_list<FieldSpec> specs) : specs_{specs}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value& value, std::string_view key) const;
};

class ValidateArrayAt final {
    std::size_t idx_;
    std::vector<FieldSpec> specs_;
 
public:
    ValidateArrayAt(std::size_t idx, std::initializer_list<FieldSpec> specs)
        : idx_{idx}, specs_{specs}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value& value, std::string_view key) const;
};

template <typename Type>
class IfType final {
public:
    template <SomeRequirement... Requirements>
    explicit IfType(Requirements&&... requirements)
        : processor_(
              [... r = std::forward<Requirements>(
                   requirements
               )](boost::json::value& j, std::string_view key) -> MaybeError {
                  std::optional<Status> firstFailure = std::nullopt;
 
                  // the check logic is the same as fieldspec
                  (
                      [&j, &key, &firstFailure, req = &r]() {
                          if (firstFailure)
                              return;
 
                          if (auto const res = req->verify(j, key); not res)
                              firstFailure = res.error();
                      }(),
                      ...);
 
                  if (firstFailure)
                      return Error{firstFailure.value()};
 
                  return {};
              }
          )
    {
    }
 
    IfType(IfType const&) = default;
    IfType(IfType&&) = default;

    [[nodiscard]] MaybeError
    verify(boost::json::value& value, std::string_view key) const
    {
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        if (not rpc::validation::checkType<Type>(value.as_object().at(key)))
            return {};  // ignore if type does not match
 
        return processor_(value, key);
    }
 
private:
    std::function<MaybeError(boost::json::value&, std::string_view)> processor_;
};

template <typename RequirementOrModifierType>
    requires SomeRequirement<RequirementOrModifierType> or SomeModifier<RequirementOrModifierType>
class WithCustomError final {
    RequirementOrModifierType reqOrModifier_;
    Status error_;
 
public:
    WithCustomError(RequirementOrModifierType reqOrModifier, Status err)
        : reqOrModifier_{std::move(reqOrModifier)}, error_{std::move(err)}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value const& value, std::string_view key) const
        requires SomeRequirement<RequirementOrModifierType>
    {
        if (auto const res = reqOrModifier_.verify(value, key); not res)
            return Error{error_};
 
        return {};
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value& value, std::string_view key) const
        requires SomeRequirement<RequirementOrModifierType>
    {
        if (auto const res = reqOrModifier_.verify(value, key); not res)
            return Error{error_};
 
        return {};
    }

    MaybeError
    modify(boost::json::value& value, std::string_view key) const
        requires SomeModifier<RequirementOrModifierType>
 
    {
        if (auto const res = reqOrModifier_.modify(value, key); not res)
            return Error{error_};
        return {};
    }
};
 
}  // namespace rpc::meta