http.h

Go to the documentation of this file.

 
#ifndef HTTPSERVER_H
#define HTTPSERVER_H
 
#include <httplib.h>
#include <unordered_map>
#include <any>
#include <functional>
#include <string>
#include <vector>
#include <nlohmann/json.hpp>
 
#include "logging.h"
 
#define REQUEST_HANDLED false
#define REQUEST_PENDING true
 
namespace mantis
{
    using json = nlohmann::json;
 
    class Context
    {
        std::unordered_map<std::string, std::any> data;
        std::string __class_name__ = "mantis::Context";
 
    public:
        Context() = default;
        void dump();
 
        template <typename T>
        void set(const std::string& key, T value)
        {
            data[key] = std::move(value);
        }
 
        template <typename T>
        std::optional<T*> get(const std::string& key)
        {
            const auto it = data.find(key);
            if (it != data.end()) return std::any_cast<T>(&it->second);
            return std::nullopt;
        }
 
        template <typename T>
        T& get_or(const std::string& key, T default_value)
        {
            if (const auto it = data.find(key); it == data.end())
            {
                data[key] = std::move(default_value);
            }
            return std::any_cast<T&>(data.at(key));
        }
    };
 
    using Request = httplib::Request;
 
    using Response = httplib::Response;
 
    using ContentReader = httplib::ContentReader;
 
    using Middleware = std::function<bool(const Request&, Response&, Context&)>;
 
    using RouteHandlerFunc = std::function<void(const httplib::Request&, httplib::Response&, Context&)>;
 
    using RouteHandlerFuncWithContentReader = std::function<void(const httplib::Request&, httplib::Response&, const httplib::ContentReader&, Context&)>;
 
    using Method = std::string;
 
    using Path = std::string;
 
    using RouteKey = std::pair<Method, Path>;
 
    struct RouteKeyHash
    {
        size_t operator()(const RouteKey& k) const;
    };
 
    struct RouteHandler
    {
        std::vector<Middleware> middlewares; 
        std::variant<RouteHandlerFunc, RouteHandlerFuncWithContentReader> handler; 
    };
 
    class RouteRegistry
    {
        std::unordered_map<RouteKey, RouteHandler, RouteKeyHash> routes;
 
    public:
        void add(const std::string& method,
                 const std::string& path,
                 RouteHandlerFunc handler,
                 const std::vector<Middleware>& middlewares);
        void add(const std::string& method,
                 const std::string& path,
                 RouteHandlerFuncWithContentReader handler,
                 const std::vector<Middleware>& middlewares);
        const RouteHandler* find(const std::string& method, const std::string& path) const;
 
        json remove(const std::string& method, const std::string& path);
 
        const std::string __class_name__ = "mantis::RouteRegistry";
    };
 
    class HttpUnit
    {
    public:
        HttpUnit();
        ~HttpUnit();
 
        void Get(const std::string& path,
                 const RouteHandlerFunc& handler,
                 std::initializer_list<Middleware> middlewares = {});
 
        void Post(const std::string& path,
                  const RouteHandlerFunc& handler,
                  std::initializer_list<Middleware> middlewares = {});
 
        void Post(const std::string& path,
                  const RouteHandlerFuncWithContentReader& handler,
                  std::initializer_list<Middleware> middlewares = {});
 
        void Patch(const std::string& path,
                   const RouteHandlerFunc& handler,
                   std::initializer_list<Middleware> middlewares = {});
 
        void Patch(const std::string& path,
                   const RouteHandlerFuncWithContentReader& handler,
                   std::initializer_list<Middleware> middlewares = {});
 
        void Delete(const std::string& path,
                    const RouteHandlerFunc& handler,
                    std::initializer_list<Middleware> middlewares = {});
 
        bool listen(const std::string& host, const int& port);
 
        void close();
 
        static Context& context();
 
        RouteRegistry& routeRegistry();
 
        httplib::Server& server();
 
        static std::string hashMultipartMetadata(const httplib::FormData& data);
 
        const std::string _class_ = "mantis::HttpUnit";
 
    private:
        std::string decompressResponseBody(const std::string& body, const std::string& encoding);
 
        using Method = void (httplib::Server::*)(const std::string&, const httplib::Server::Handler&);
 
        template <typename HandlerType>
        using MethodBinder = std::function<void(const std::string&, HandlerType)>;
 
        void route(const MethodBinder<httplib::Server::Handler>& bind_method,
                   const std::string& method,
                   const std::string& path,
                   const RouteHandlerFunc& handler,
                   std::initializer_list<Middleware> middlewares);
 
        void route(const MethodBinder<httplib::Server::HandlerWithContentReader>& bind_method,
                   const std::string& method,
                   const std::string& path,
                   const RouteHandlerFuncWithContentReader& handler,
                   std::initializer_list<Middleware> middlewares);
 
        template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
        template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
 
        httplib::Server svr;
        RouteRegistry registry;
        thread_local static Context current_context;
    };
}
 
#endif // HTTPSERVER_H