session.hpp

#pragma once
 
#include "types.hpp"
#include "../cookie.hpp"
 
#include <functional>
#include <string>
#include <unordered_map>
#include <optional>
 
namespace malloy::http::sessions
{

    struct session
    {
        using key_type    = std::string;
        using value_type  = std::string;
        using id_type     = std::string;

        explicit
        session(id_type&& id) :
            m_id(std::move(id))
        {
        }

        virtual
        ~session() = default;

        session(const session& other) = delete;

        session(session&& other) noexcept = delete;

        session&
        operator=(const session& other) = delete;

        session&
        operator=(session&& other) noexcept = delete;

        bool
        set(const key_type& key, value_type value)
        {
            if (key.empty() || value.empty())
                return false;
 
            update_access_time();
            return storage_set(key, std::move(value));
        }

        [[nodiscard]]
        std::optional<key_type>
        get(const key_type& key)
        {
            if (key.empty())
                return std::nullopt;
 
            update_access_time();
            const auto& value_opt = storage_get(key);
 
            // Prevent returning empty values
            if (value_opt && value_opt.value().empty())
                return std::nullopt;
 
            return value_opt;
        }

        [[nodiscard]]
        virtual
        bool
        remove(const key_type& key)
        {
            if (key.empty())
                return false;
 
            update_access_time();
            return storage_remove(key);
        }

        [[nodiscard]]
        id_type
        id() const noexcept
        {
            return m_id;
        }

        [[nodiscard]]
        cookie
        generate_cookie(std::string cookie_name) const
        {
            return cookie {
                .name = std::move(cookie_name),
                .value = m_id,
                .max_age = { },
                .expires = "",
                .domain = "",
                .path = "",
                .secure = true,
                .http_only = true,
                .same_site = cookie::same_site_t::strict,
            };
        }
 
    protected:
        virtual
        bool
        storage_set(const key_type& key, value_type value) = 0;

        [[nodiscard]]
        virtual
        std::optional<value_type>
        storage_get(const key_type& key) const = 0;

        [[nodiscard]]
        virtual
        bool
        storage_remove(const key_type& key) = 0;

        virtual
        void
        update_access_time() = 0;
 
    private:
        id_type m_id;
    };

    template<typename Clock>
    struct session_chrono :
        session
    {
        using time_point_t = std::chrono::time_point<Clock>;
 
    public:
        explicit
        session_chrono(id_type&& id) :
            session(std::move(id))
        {
            m_access_time = Clock::now();
        }

        time_point_t
        access_time() const noexcept
        {
            return m_access_time;
        }

        template<typename Rep, typename Period>
        [[nodiscard]]
        constexpr
        bool
        access_time_older_than(const std::chrono::duration<Rep, Period>& max_lifetime) const
        {
            return (Clock::now() - m_access_time) > max_lifetime;
        }
 
    protected:
        void
        update_access_time() override
        {
            m_access_time = Clock::now();
        }
 
    private:
        time_point_t m_access_time;
    };
 
}