mantisbase.h

Go to the documentation of this file.

 
#ifndef MANTISBASE_APP_H
#define MANTISBASE_APP_H
 
#include <memory>
#include <string>
#include <filesystem>
#include <chrono>
#include <argparse/argparse.hpp>
// #include <dukglue/dukglue.h>
 
#include "core/types.h"
#include "core/kv_store.h"
 
namespace mb
{
    class RealtimeDB;
    class MantisBase
    {
    public:
        ~MantisBase();
 
        // Disable copying and moving
        MantisBase(const MantisBase&) = delete;
        MantisBase& operator=(const MantisBase&) = delete;
        MantisBase(MantisBase&&) = delete;
        MantisBase& operator=(MantisBase&&) = delete;
 
        static MantisBase& instance();
 
        static MantisBase& create(int argc, char** argv);
 
        static MantisBase& create(const json& config = json::object());
 
        [[nodiscard]] int run();
 
        void close();
 
        static int quit(const int& exitCode = 0, const std::string& reason = "Something went wrong!");
 
        [[nodiscard]] int port() const;
        void setPort(const int& port);
 
        [[nodiscard]] int poolSize() const;
 
        [[nodiscard]] std::string host() const;
        void setHost(const std::string& host);
 
        [[nodiscard]] std::string publicDir() const;
        void setPublicDir(const std::string& dir);
 
        [[nodiscard]] std::string dataDir() const;
        void setDataDir(const std::string& dir);
 
        [[nodiscard]] std::string scriptsDir() const;
        void setScriptsDir(const std::string& dir);
 
        [[nodiscard]] std::string migrationsDir() const;
        void setMigrationsDir(const std::string& dir);
 
        [[nodiscard]] bool skipAdminSetup() const;
        void setSkipAdminSetup(bool skip);
 
        [[nodiscard]] std::string dbType() const;
 
        void setDbType(const std::string& dbType);
        static std::string jwtSecretKey();
        static std::string appVersion();
        static int appMinorVersion();
        static int appMajorVersion();
        static int appPatchVersion();
 
        [[nodiscard]] Database& db() const;
        [[nodiscard]] argparse::ArgumentParser& cmd() const;
        [[nodiscard]] Router& router() const;
        [[nodiscard]] KeyValStore& settings() const;
        [[nodiscard]] Logger& logs() const;
        [[nodiscard]] RealtimeDB& rt() const;
 
        [[nodiscard]] Entity entity(const std::string& entity_name) const;
 
        [[nodiscard]] bool hasEntity(const std::string& entity_name) const;
 
        // [[nodiscard]] duk_context* ctx() const;
 
 
        void openBrowserOnStart() const;
 
        [[nodiscard]] std::chrono::time_point<std::chrono::steady_clock> startTime() const;
 
        [[nodiscard]] bool isDevMode() const;
 
    private:
        // Make class creation private to enforce
        // singleton app pattern.
        MantisBase();
 
        void init(int argc = 0, char* argv[] = {});
 
        static MantisBase& getInstanceImpl();
 
        void setPoolSize(const int& pool_size);
 
 
        // Private members
        void parseArgs(); 
        void init_units(); 
 
        [[nodiscard]]
        bool ensureDirsAreCreated() const; 
 
        [[nodiscard]] bool isCreated() const;
 
#ifdef MB_SCRIPTING_ENABLED
        void initJSEngine();
 
        void loadStartScript() const;
 
        void loadAndExecuteScript(const std::string& filePath) const;
 
        void loadScript(const std::string& relativePath) const;
 
        std::string version_JSWrapper() const { return appVersion(); }
        std::string jwtSecretKey_JSWrapper() const { return jwtSecretKey(); }
        void quit_JSWrapper(int code, const std::string& msg);
 
        [[nodiscard]] Database* duk_db() const;
        [[nodiscard]] Router* duk_router() const;
#endif
 
        // Store commandline args passed in, to be used in the init phase.
        std::vector<std::string> m_cmdArgs;
 
        // Hold state if the instance has be initialized already!
        std::atomic<bool> m_isCreated = false;
 
        std::string m_publicDir;
        std::string m_dataDir;
        std::string m_scriptsDir;
        std::string m_migrationsDir;
        std::string m_dbType;
 
        // System uptime checkpoint
        std::chrono::time_point<std::chrono::steady_clock> m_startTime;
 
        int m_port = 7070;
        std::string m_host = "127.0.0.1";
 
        // For snowflake ID generation
        uint8_t m_zoneId = 0;
        uint8_t m_shardNo = 0;
 
        //
        int m_poolSize = 2;
        bool m_toStartServer = false;
        bool m_launchAdminPanel = false;
        bool m_isDevMode = false;
        bool m_skipAdminSetup = false;
 
        std::unique_ptr<Logger> m_logger;
        std::unique_ptr<Database> m_database;
        std::unique_ptr<RealtimeDB> m_realtime;
        std::unique_ptr<Router> m_router;
        std::unique_ptr<KeyValStore> m_kvStore;
        std::unique_ptr<argparse::ArgumentParser> m_opts;
        // duk_context* m_dukCtx; // For duktape context
    };
}
 
#endif //MANTISBASE_APP_H