Struct AccountInsertService 

pub struct AccountInsertService<R, G>
where
    R: AccessHierarchy + Eq,
    G: Eq,
{ /* private fields */ }

Service for creating new user accounts with their associated authentication secrets.

This service provides an ergonomic builder pattern for creating accounts with roles, groups, and permissions, then storing both the account data and authentication secrets in their respective repositories.

Basic Usage

use axum_gate::accounts::AccountInsertService;
use axum_gate::prelude::{Role, Group};
use axum_gate::repositories::memory::{MemoryAccountRepository, MemorySecretRepository};
use std::sync::Arc;

let account_repo = Arc::new(MemoryAccountRepository::<Role, Group>::default());
let secret_repo = Arc::new(MemorySecretRepository::new_with_argon2_hasher().unwrap());

let account = AccountInsertService::insert("user@example.com", "secure_password")
    .with_roles(vec![Role::User])
    .with_groups(vec![Group::new("staff")])
    .into_repositories(account_repo, secret_repo)
    .await
    .unwrap()
    .unwrap();

println!("Created account: {}", account.user_id);

Implementations

impl<R, G> AccountInsertService<R, G>

where R: AccessHierarchy + Eq, G: Eq + Clone,

pub fn insert(user_id: &str, secret: &str) -> Self

Creates a new account insertion builder with the specified credentials.

This is the starting point for creating a new account. The user ID should be unique within your application (typically an email or username), and the secret will be hashed before storage using Argon2.

Arguments

• user_id - Unique identifier for the user (e.g., email or username)
• secret - Plain text password that will be securely hashed

Example

use axum_gate::accounts::AccountInsertService;
use axum_gate::prelude::{Role, Group};

let builder = AccountInsertService::<Role, Group>::insert("admin@example.com", "strong_password");
// Continue with .with_roles(), .with_groups(), etc.

pub fn with_roles(self, roles: Vec<R>) -> Self

Adds roles to the account being created.

Roles determine what actions the user can perform. Use the pre-defined Role enum or create your own custom role type.

Example

use axum_gate::accounts::AccountInsertService;
use axum_gate::prelude::{Role, Group};

let builder = AccountInsertService::<Role, Group>::insert("user@example.com", "password")
    .with_roles(vec![Role::User, Role::Reporter]);

pub fn with_groups(self, groups: Vec<G>) -> Self

Adds groups to the account being created.

Groups provide organizational structure for users, such as department or team membership. They offer another dimension of access control.

Example

use axum_gate::accounts::AccountInsertService;
use axum_gate::prelude::{Role, Group};

let builder = AccountInsertService::<Role, Group>::insert("user@example.com", "password")
    .with_groups(vec![Group::new("engineering"), Group::new("backend-team")]);

pub fn with_permissions(self, permissions: Permissions) -> Self

Adds custom permissions to the account being created.

This method allows you to set specific permissions using the zero-synchronization permission system. Permissions are stored as a compressed bitmap for efficiency.

Arguments

• permissions - A Permissions set containing the permission names

Example

use axum_gate::accounts::AccountInsertService;
use axum_gate::permissions::Permissions;
use axum_gate::prelude::{Role, Group};

let permissions: Permissions = [
    "read:api",
    "write:api",
    "manage:users"
].into_iter().collect();

let builder = AccountInsertService::<Role, Group>::insert("admin@example.com", "password")
    .with_permissions(permissions);

pub async fn into_repositories<AccRepo, SecRepo>( self, account_repository: Arc<AccRepo>, secret_repository: Arc<SecRepo>, ) -> Result<Option<Account<R, G>>>

where AccRepo: AccountRepository<R, G>, SecRepo: SecretRepository,

Creates the account and secret, storing them in the provided repositories.

This method consumes the builder and performs the actual account creation:

1. Creates an Account with the specified details
2. Stores the account in the account repository
3. Hashes the password using Argon2
4. Creates and stores the secret in the secret repository

Both operations must succeed for the account to be considered created.

Arguments

• account_repository - Repository for storing account data
• secret_repository - Repository for storing password hashes

Returns

• Ok(Some(Account)) - Account successfully created
• Ok(None) - Account creation failed (repository returned None)
• Err(...) - Error during creation process

Example

use axum_gate::accounts::AccountInsertService;
use axum_gate::prelude::{Role, Group};
use axum_gate::repositories::memory::{MemoryAccountRepository, MemorySecretRepository};
use std::sync::Arc;

let account_repo = Arc::new(MemoryAccountRepository::<Role, Group>::default());
let secret_repo = Arc::new(MemorySecretRepository::new_with_argon2_hasher().unwrap());

let result = AccountInsertService::insert("user@example.com", "password")
    .with_roles(vec![Role::User])
    .into_repositories(account_repo, secret_repo)
    .await?;

match result {
    Some(account) => println!("Created account: {}", account.user_id),
    None => println!("Account creation failed"),
}