router.h

Go to the documentation of this file.

#pragma once
 
#include <uwebsockets/App.h>
 
#include <BS_thread_pool.hpp>
#include <atomic>
#include <charconv>
#include <chrono>
#include <concepts>
#include <functional>
#include <nlohmann/json.hpp>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace mm::api {
 
 
class Request {
 public:
  Request(std::string url, std::vector<std::pair<std::string, std::string>> parameters,
          std::string queryString, std::vector<std::pair<std::string, std::string>> headers,
          std::string body)
      : url_(std::move(url)),
        parameters_(std::move(parameters)),
        queryString_(std::move(queryString)),
        headers_(std::move(headers)),
        body_(std::move(body)) {}
 
  std::string_view url() const { return url_; }
 
  const std::string& body() const { return body_; }
 
  std::string_view header(std::string_view name) const {
    for (const auto& [key, value] : headers_) {
      if (key == name) {
        return value;
      }
    }
    return {};
  }
 
  bool accepts(std::string_view contentType) const {
    return header("accept").find(contentType) != std::string_view::npos;
  }
 
  std::string_view parameter(std::string_view name) const {
    for (const auto& [key, value] : parameters_) {
      if (key == name) {
        return value;
      }
    }
    return {};
  }
 
  std::optional<std::string> query(std::string_view key) const;
 
  template <typename T>
  std::optional<T> parameterAs(std::string_view name) const {
    return parseNumber<T>(parameter(name));
  }
 
  template <typename T>
  std::optional<T> queryAs(std::string_view key) const {
    auto value = query(key);
    return value ? parseNumber<T>(*value) : std::nullopt;
  }
 
 private:
  template <typename T>
  static std::optional<T> parseNumber(std::string_view text) {
    if (text.empty()) {
      return std::nullopt;
    }
    const bool hex = text.size() > 2 && text[0] == '0' && (text[1] == 'x' || text[1] == 'X');
    const std::string_view digits = hex ? text.substr(2) : text;
    T value{};
    const auto [ptr, ec] =
        std::from_chars(digits.data(), digits.data() + digits.size(), value, hex ? 16 : 10);
    if (ec != std::errc{} || ptr != digits.data() + digits.size()) {  // NOLINT(whitespace/braces)
      return std::nullopt;
    }
    return value;
  }
 
  std::string url_;
  std::vector<std::pair<std::string, std::string>> parameters_;
  std::string queryString_;
  std::vector<std::pair<std::string, std::string>> headers_;
  std::string body_;
};
 
struct Response {
  std::string status = "200 OK";
  std::string contentType = "application/json";
  std::string body;
  std::vector<std::pair<std::string, std::string>> headers;
};
 
std::string percentDecode(std::string_view text);
 
std::vector<std::string> parameterNames(std::string_view pattern);
 
Response json(const nlohmann::json& body);
 
Response bytes(std::string contentType, std::string body);
 
Response error(std::string status, std::string_view message);
 
Response badRequest(std::string_view message);
 
Response notFound(std::string_view message);
 
Response statusOnly(std::string status);
 
Response withWireTime(Response response, std::chrono::microseconds wireUs);
 
template <typename Op>
Response timed(Op&& op, std::string errorStatus = "500 Internal Server Error") {
  const auto t0 = std::chrono::steady_clock::now();
  auto result = std::forward<Op>(op)();
  const auto wireUs =
      std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - t0);
  if (!result) {
    return withWireTime(error(std::move(errorStatus), result.error()), wireUs);
  }
  return withWireTime(json(nlohmann::json(*result)), wireUs);
}
 
template <typename Op, typename StatusOf>
  requires std::invocable<StatusOf&, const typename std::invoke_result_t<Op&>::error_type&>
Response timed(Op&& op, StatusOf&& statusOf) {
  const auto t0 = std::chrono::steady_clock::now();
  auto result = std::forward<Op>(op)();
  const auto wireUs =
      std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - t0);
  if (!result) {
    return withWireTime(error(std::string(statusOf(result.error())), result.error().message),
                        wireUs);
  }
  return withWireTime(json(nlohmann::json(*result)), wireUs);
}
 
using Handler = std::function<Response(const Request&)>;
 
class Router {
 public:
  Router(uWS::SSLApp& app, uWS::Loop* loop, BS::light_thread_pool& pool,
         const std::atomic<bool>& stopping, std::string_view corsOrigin)
      : app_(app), loop_(loop), pool_(pool), stopping_(stopping), corsOrigin_(corsOrigin) {}
 
  void get(const std::string& pattern, Handler handler) {
    add("GET", pattern, std::move(handler), /*hasBody=*/false);
  }
  void post(const std::string& pattern, Handler handler) {
    add("POST", pattern, std::move(handler), /*hasBody=*/true);
  }
  void put(const std::string& pattern, Handler handler) {
    add("PUT", pattern, std::move(handler), /*hasBody=*/true);
  }
  void del(const std::string& pattern, Handler handler) {
    add("DELETE", pattern, std::move(handler), /*hasBody=*/false);
  }
 
 private:
  void add(std::string_view method, const std::string& pattern, Handler handler, bool hasBody);
 
  uWS::SSLApp& app_;
  uWS::Loop* loop_;
  BS::light_thread_pool& pool_;
  const std::atomic<bool>& stopping_;
  std::string_view corsOrigin_;
};
 
}  // namespace mm::api