App.hpp

#pragma once
 
#include "magpie/AppDecl.hpp"
#include "magpie/application/Methods.hpp"
#include "magpie/config/AppConfig.hpp"
#include "magpie/data/CommonData.hpp"
#include "magpie/middlewares/Middleware.hpp"
#include "magpie/routing/Compile.hpp"
#include "magpie/routing/Router.hpp"
#include "magpie/transport/TCPServer.hpp"
#include "raven/config/SSLConfig.hpp"
#include <memory>
#include <type_traits>
 
namespace magpie {
 
template <data::IsCommonData ContextType = data::CommonData>
class App : public ContextApp<ContextType> {
private:
    transport::TCPServer serv;
 
    std::shared_ptr<ContextType> dataStore;
    std::shared_ptr<routing::BaseRouter> router;
 
    std::shared_ptr<Middlewares<ContextType>> middlewares;
 
public:
 
    App(
        std::shared_ptr<ContextType> dataStore,
        AppConfig&& conf = {},
        std::optional<raven::SSLConfig>&& sslConfig = std::nullopt
    ): ContextApp<ContextType>(std::move(conf)),
        serv(
            this,
            this->config.port,
            this->config.concurrency,
            this->config.bindAddr,
            std::move(sslConfig)
        ),
        dataStore(dataStore),
        router(std::make_shared<routing::Router<ContextType>>()),
        middlewares(std::make_shared<Middlewares<ContextType>>())
    {
        dataStore->app = (BaseApp*) this;
    }
 
    // Not sure why clangd and/or clang-tidy whines about this being incorrect use; adding ::type breaks the build in
    // all the combinations of `typename = [typename] std::enable_if[_v]<>[::type]` I could think of
    template <typename = std::enable_if<std::is_trivially_default_constructible_v<ContextType>>>
    App(
        AppConfig&& conf = {},
        std::optional<raven::SSLConfig>&& sslConfig = std::nullopt
    ): App(std::make_shared<ContextType>(), std::move(conf), std::move(sslConfig)) {
 
    }
    ~App() = default;

    template <
        routing::FixedString path,
        Method::HttpMethod method
    >
    routing::BaseRoute<ContextType>* route(
        const routing::RouteCallback<path, ContextType>& callback
    ) {
        return std::static_pointer_cast<routing::Router<ContextType>>(router)
            ->template registerRoute<path>(
                callback,
                method
            );
    }
 
    void run() override {
        serv.start();
    }
 
    void shutdown() override {
        serv.stop();
    }
 
    uint16_t getPort() {
        return this->serv.getPort();
    }
 
    void sync() {
        this->serv.sync();
    }
 
    const routing::BaseRouter& getRouter() override {
        return *this->router;
    }
 
    data::CommonData* getContext() const override {
        return this->dataStore.get();
    }
 
    void registerGlobalMiddlewares(
        const std::vector<std::shared_ptr<Middleware<ContextType>>>& middlewares
    ) {
        this->middlewares->middlewares = middlewares;
    }
    
    Middlewares<ContextType>* getMiddlewaresAsPtr() override {
        return this->middlewares.get();
    }
 
};
 
}