models.h

Go to the documentation of this file.

//
// Created by allan on 08/05/2025.
//
 
#ifndef MODELS_H
#define MODELS_H
 
#include <optional>
#include <soci/soci.h>
#include <nlohmann/json.hpp>
 
namespace mantis
{
    using json = nlohmann::json;
 
    class MantisApp;
 
    class Validator
    {
        std::unordered_map<std::string, json> m_validators;
 
    public:
        Validator();
 
        std::optional<json> find(const std::string& key);
 
        json validate(const std::string& key, const std::string& value);
    };
 
 
 
    // Enum of the table type created,
    // base table types provide `index`, `created`, `updated`
    // auth table type provide `base` type + `email`, `password`, `name`
    // view table type provide readonly `sql`
    typedef enum class TableType
    {
        Base = 1,
        Auth,
        View
    } TableType;
 
    NLOHMANN_JSON_SERIALIZE_ENUM(TableType, {
        {TableType::Base, "base"},
        {TableType::Auth, "auth"},
        {TableType::View, "view"}
    })
 
    typedef enum class FieldTypeDecl {
        XML         = soci::db_xml,
        STRING      = soci::db_string,
        DOUBLE      = soci::db_double,
        DATE        = soci::db_date,
        INT8        = soci::db_int8,
        UINT8       = soci::db_uint8,
        INT16       = soci::db_int16,
        UINT16      = soci::db_uint16,
        INT32       = soci::db_int32,
        UINT32      = soci::db_uint32,
        INT64       = soci::db_int64,
        UINT64      = soci::db_uint64,
        BLOB        = soci::db_blob,
        // User defined types
        JSON,
        BOOL
    } FieldType;
 
    NLOHMANN_JSON_SERIALIZE_ENUM(FieldType, {
        { FieldType::XML,       "xml"    },
        { FieldType::STRING,    "string" },
        { FieldType::DOUBLE,    "double" },
        { FieldType::DATE,      "date"   },
        { FieldType::INT8,      "int8"   },
        { FieldType::UINT8,     "uint8"  },
        { FieldType::INT16,     "int16"  },
        { FieldType::UINT16,    "uint16" },
        { FieldType::INT32,     "int32"  },
        { FieldType::UINT32,    "uint32" },
        { FieldType::INT64,     "int64"  },
        { FieldType::UINT64,    "uint64" },
        { FieldType::BLOB,      "blob"   },
        { FieldType::JSON,      "json"   },
        { FieldType::BOOL,      "bool"   },
    })
 
    const std::vector<std::string> baseFields = {"id", "created", "updated"};
    const std::vector<std::string> authFields = {"id", "created", "updated", "name", "email", "password"};
 
    std::optional<FieldType> getFieldType(const std::string& fieldName);
 
    bool fieldExists(const TableType& type, const std::string& fieldName);
 
    bool isValidFieldType(const std::string& fieldType);
 
    // Access rule expression
    typedef std::string Rule;
 
    // Field definition
    struct Field {
        std::string name;
        FieldType type;
 
        bool required = false;
        bool primaryKey = false;
        bool system = false;
 
        std::optional<std::string> defaultValue;        // as string, parse based on type
        std::optional<std::string> regexPattern;
        std::optional<double> minValue;
        std::optional<double> maxValue;
        bool isUnique = false;
        std::optional<std::string> validator;
        std::optional<std::string> autoGeneratePattern; // regex for auto-gen strings
 
        // Convenience constructor
        Field(std::string n, FieldType t, bool req = false, bool pk = false, bool sys = false, json opts = json::object());
 
        [[nodiscard]]
        json to_json() const;
 
        [[nodiscard]]
        soci::db_type toSociType() const;
 
        [[nodiscard]]
        static soci::db_type toSociType(const FieldType& f_type);
    };
 
    // Represents a generic table in the system
    struct Table {
        virtual ~Table() = default;
        std::string id;
        std::string name;
        TableType type;
        bool system = false;
        bool has_api = true;
 
        std::vector<Field> fields;
 
        Rule listRule;
        Rule getRule;
        Rule addRule;
        Rule updateRule;
        Rule deleteRule;
 
        // Constructor
        Table() = default;
 
        [[nodiscard]]
        virtual json to_json() const;
 
        [[nodiscard]]
        virtual std::string to_sql() const;
    };
 
    // Specific model for Base table (user-defined)
    struct BaseTable : Table {
        bool enableSync = true;
 
        BaseTable();
    };
 
    // Specific model for Auth table
    struct AuthTable : Table
    {
        std::string usernameField = "email";
        std::string passwordField = "password";
        bool enableSync = true;
 
        // Member Functions
        AuthTable();
        ~AuthTable() override = default;
    };
 
    // Specific model for View table
    struct ViewTable : Table {
        std::string sourceSQL;
        bool enableSync = false;
 
        ViewTable();
    };
 
    struct SystemTable final : BaseTable {
        bool enableSync = true;
 
        SystemTable();
        ~SystemTable() override = default;
    };
 
    struct AdminTable final : AuthTable {
        bool enableSync = true;
 
        AdminTable();
    };
}
 
#endif //MODELS_H