/**

*

* @file AuthModule.cpp

* @author Gaspard Kirira

*

* Copyright 2026, Gaspard Kirira.

* All rights reserved.

* https://github.com/rixcpp/auth

*

* Use of this source code is governed by a MIT license

* that can be found in the License file.

*

* Rix

*

*/

#include <rix/auth/AuthModule.hpp>

#include <cstddef>

#include <memory>

#include <string>

#include <string_view>

#include <utility>

namespace rixlib::auth

{

namespace

{

[[nodiscard]] AuthError configuration_error(std::string message)

{

return make_auth_error(

AuthErrorCode::ConfigurationError,

std::move(message));

}

[[nodiscard]] AuthError invalid_store_error(std::string message)

{

return make_auth_error(

AuthErrorCode::InvalidState,

std::move(message));

}

} // namespace

AuthError AuthErrorModule::none() const

{

return make_auth_ok();

}

AuthError AuthErrorModule::make(

AuthErrorCode code,

std::string message) const

{

return make_auth_error(code, std::move(message));

}

std::string_view AuthErrorModule::to_string(

AuthErrorCode code) const noexcept

{

return rixlib::auth::to_string(code);

}

std::string_view AuthErrorModule::to_string(

const AuthError &error) const noexcept

{

return rixlib::auth::to_string(error.code());

}

bool AuthErrorModule::ok(const AuthError &error) const noexcept

{

return error.ok();

}

bool AuthErrorModule::failed(const AuthError &error) const noexcept

{

return error.has_error();

}

bool AuthErrorModule::is(

const AuthError &error,

AuthErrorCode code) const noexcept

{

return error.is(code);

}

AuthConfig AuthConfigModule::development() const

{

return AuthConfig::development();

}

AuthConfig AuthConfigModule::production() const

{

return AuthConfig::production();

}

AuthConfig AuthConfigModule::development_with_min_password_length(

std::size_t min_length) const

{

auto config = AuthConfig::development();

config.set_min_password_length(min_length);

return config;

}

AuthConfig AuthConfigModule::production_with_min_password_length(

std::size_t min_length) const

{

auto config = AuthConfig::production();

config.set_min_password_length(min_length);

return config;

}

bool AuthConfigModule::valid(const AuthConfig &config) const noexcept

{

return validate(config).ok();

}

AuthStatus AuthConfigModule::validate(const AuthConfig &config) const

{

if (config.min_password_length() == 0)

{

return AuthStatus::failure(

configuration_error("Minimum password length must be greater than zero."));

}

if (config.max_password_length() == 0)

{

return AuthStatus::failure(

configuration_error("Maximum password length must be greater than zero."));

}

if (config.min_password_length() > config.max_password_length())

{

return AuthStatus::failure(

configuration_error(

"Minimum password length cannot be greater than maximum password length."));

}

if (config.session_ttl_seconds() <= 0)

{

return AuthStatus::failure(

configuration_error("Session lifetime must be greater than zero."));

}

if (config.token_ttl_seconds() <= 0)

{

return AuthStatus::failure(

configuration_error("Token lifetime must be greater than zero."));

}

if (config.password_hash_iterations() == 0)

{

return AuthStatus::failure(

configuration_error("Password hash iterations must be greater than zero."));

}

if (config.password_salt_size() == 0)

{

return AuthStatus::failure(

configuration_error("Password salt size must be greater than zero."));

}

if (config.password_hash_size() == 0)

{

return AuthStatus::failure(

configuration_error("Password hash size must be greater than zero."));

}

if (config.issuer().empty())

{

return AuthStatus::failure(

configuration_error("Token issuer cannot be empty."));

}

return AuthStatus::success();

}

AuthResult<std::string> AuthPasswordModule::hash(

std::string_view password) const

{

PasswordHasher hasher;

return hasher.hash(password);

}

AuthResult<std::string> AuthPasswordModule::hash(

std::string_view password,

const AuthConfig &config) const

{

PasswordHasher hasher(config);

return hasher.hash(password);

}

bool AuthPasswordModule::verify(

std::string_view password,

std::string_view password_hash) const

{

PasswordHasher hasher;

return hasher.verify(password, password_hash);

}

bool AuthPasswordModule::verify(

std::string_view password,

std::string_view password_hash,

const AuthConfig &config) const

{

PasswordHasher hasher(config);

return hasher.verify(password, password_hash);

}

bool AuthPasswordModule::accepts(std::string_view password) const

{

PasswordHasher hasher;

return hasher.accepts(password);

}

bool AuthPasswordModule::accepts(

std::string_view password,

const AuthConfig &config) const

{

PasswordHasher hasher(config);

return hasher.accepts(password);

}

PasswordHasher AuthPasswordModule::hasher() const

{

return PasswordHasher{};

}

PasswordHasher AuthPasswordModule::hasher(const AuthConfig &config) const

{

return PasswordHasher{config};

}

std::unique_ptr<UserStore> AuthStoreModule::memory_users() const

{

return std::make_unique<MemoryUserStore>();

}

std::unique_ptr<SessionStore> AuthStoreModule::memory_sessions() const

{

return std::make_unique<MemorySessionStore>();

}

std::unique_ptr<UserStore> AuthStoreModule::database_users(

vix::db::Database &database) const

{

return std::make_unique<DbUserStore>(database);

}

std::unique_ptr<SessionStore> AuthStoreModule::database_sessions(

vix::db::Database &database) const

{

return std::make_unique<DbSessionStore>(database);

}

Auth AuthModule::create(

UserStore &users,

SessionStore &sessions) const

{

return Auth{

users,

sessions,

AuthConfig::development()};

}

Auth AuthModule::create(

UserStore &users,

SessionStore &sessions,

AuthConfig config) const

{

return Auth{

users,

sessions,

std::move(config)};

}

AuthResult<ManagedAuth> AuthModule::managed(

std::unique_ptr<UserStore> users,

std::unique_ptr<SessionStore> sessions) const

{

return managed(

std::move(users),

std::move(sessions),

AuthConfig::development());

}

AuthResult<ManagedAuth> AuthModule::managed(

std::unique_ptr<UserStore> users,

std::unique_ptr<SessionStore> sessions,

AuthConfig config) const

{

if (!users)

{

return AuthResult<ManagedAuth>::failure(

invalid_store_error("User store cannot be null."));

}

if (!sessions)

{

return AuthResult<ManagedAuth>::failure(

invalid_store_error("Session store cannot be null."));

}

const auto validation = this->config.validate(config);

if (validation.failed())

{

return AuthResult<ManagedAuth>::failure(validation.error());

}

return AuthResult<ManagedAuth>::success(

ManagedAuth{

std::move(users),

std::move(sessions),

std::move(config)});

}

ManagedAuth AuthModule::memory() const

{

return memory(AuthConfig::development());

}

ManagedAuth AuthModule::memory(AuthConfig config) const

{

auto users = std::make_unique<MemoryUserStore>();

auto sessions = std::make_unique<MemorySessionStore>();

return ManagedAuth{

std::move(users),

std::move(sessions),

std::move(config)};

}

ManagedAuth AuthModule::database(vix::db::Database &database) const

{

return this->database(

database,

AuthConfig::production());

}

ManagedAuth AuthModule::database(

vix::db::Database &database,

AuthConfig config) const

{

auto users = std::make_unique<DbUserStore>(database);

auto sessions = std::make_unique<DbSessionStore>(database);

return ManagedAuth{

std::move(users),

std::move(sessions),

std::move(config)};

}

std::string AuthModule::version() const

{

return rixlib::auth::version();

}

int AuthModule::version_major() const noexcept

{

return rixlib::auth::version_major();

}

int AuthModule::version_minor() const noexcept

{

return rixlib::auth::version_minor();

}

int AuthModule::version_patch() const noexcept

{

return rixlib::auth::version_patch();

}

int AuthModule::version_number() const noexcept

{

return rixlib::auth::version_number();

}

} // namespace rixlib::auth